home *** CD-ROM | disk | FTP | other *** search
/ Network PC / Network PC.iso / amiga utilities / communication / bbs / termv4.6 / extras / source / term-source.lha / PhonePanel.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-03-18  |  84.0 KB  |  3,411 lines

  1. /*
  2. **    PhonePanel.c
  3. **
  4. **    The phonebook and support routines
  5. **
  6. **    Copyright © 1990-1996 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. **
  9. **    :ts=4
  10. */
  11.  
  12. #ifndef _GLOBAL_H
  13. #include "Global.h"
  14. #endif
  15.  
  16.     // The gadget IDs are in there
  17.  
  18. #include "PhonePanel.h"
  19.  
  20.     /* What action is to follow clicking into the listview. */
  21.  
  22. enum    {    CLICK_NONE,CLICK_SELECT,CLICK_TOGGLE,CLICK_DIAL };
  23.  
  24. STATIC VOID
  25. HighlightEntry(LayoutHandle *Manager,LayoutHandle *Editor,struct List *PhoneList,struct PhoneNode *Node,ULONG Count,ULONG Grouper,BOOL Activate,BOOL Hide,BOOL NewList)
  26. {
  27.     BOOL IsFirst,IsLast,Disabled;
  28.  
  29.     if(Node && PhoneList)
  30.     {
  31.         IsFirst        = (Node == (struct PhoneNode *)PhoneList -> lh_Head);
  32.         IsLast        = (Node == (struct PhoneNode *)PhoneList -> lh_TailPred);
  33.         Disabled    = FALSE;
  34.     }
  35.     else
  36.     {
  37.         IsFirst        = TRUE;
  38.         IsLast        = TRUE;
  39.         Disabled    = TRUE;
  40.     }
  41.  
  42.     if(PhoneList)
  43.     {
  44.         LT_SetAttributes(Manager,GAD_NAMELIST,
  45.             NewList ? GTLV_Labels : TAG_IGNORE,    PhoneList,
  46.             Node ? TAG_IGNORE : GTLV_Selected,    ~0,
  47.         TAG_DONE);
  48.     }
  49.     else
  50.     {
  51.         LT_SetAttributes(Manager,GAD_NAMELIST,
  52.             GTLV_Labels,                        NULL,
  53.             Node ? TAG_IGNORE : GTLV_Selected, ~0,
  54.             Kick30 ? GA_Disabled : TAG_IGNORE,    TRUE,
  55.         TAG_DONE);
  56.     }
  57.  
  58.     LT_SetAttributes(Manager,GAD_COMMENTLINE,
  59.         LABX_Text,    Node ? Node -> Entry -> Header -> Comment : (STRPTR)"",
  60.     TAG_DONE);
  61.  
  62.     LT_SetAttributes(Manager,GAD_MOVE_FIRST,
  63.         GA_Disabled,    IsFirst || Disabled,
  64.     TAG_DONE);
  65.  
  66.     LT_SetAttributes(Manager,GAD_MOVE_UP,
  67.         GA_Disabled,    IsFirst || Disabled,
  68.     TAG_DONE);
  69.  
  70.     LT_SetAttributes(Manager,GAD_MOVE_DOWN,
  71.         GA_Disabled,    IsLast || Disabled,
  72.     TAG_DONE);
  73.  
  74.     LT_SetAttributes(Manager,GAD_MOVE_LAST,
  75.         GA_Disabled,    IsLast || Disabled,
  76.     TAG_DONE);
  77.  
  78.     LT_SetAttributes(Manager,GAD_EDIT,
  79.         GA_Disabled,    !Node || Disabled,
  80.     TAG_DONE);
  81.  
  82.     LT_SetAttributes(Manager,GAD_COPY,
  83.         GA_Disabled,    !Node || Disabled,
  84.     TAG_DONE);
  85.  
  86.     LT_SetAttributes(Manager,GAD_DELETE,
  87.         GA_Disabled,    !Node || Disabled || Node -> Entry == ChosenEntry,
  88.     TAG_DONE);
  89.  
  90.     LT_SetAttributes(Manager,GAD_USE,
  91.         GA_Disabled,    !Node || Disabled,
  92.     TAG_DONE);
  93.  
  94.     LT_SetAttributes(Manager,GAD_MAKE_GROUP,
  95.         GA_Disabled,    !Node && !Count,
  96.     TAG_DONE);
  97.  
  98.     LT_SetAttributes(Manager,GAD_SPLIT_GROUP,
  99.         GA_Disabled,    Grouper == 0,
  100.     TAG_DONE);
  101.  
  102.     LT_SetAttributes(Manager,GAD_SELECT,
  103.         GA_Disabled,    Disabled || (Node && Node -> Entry -> Count != -1),
  104.     TAG_DONE);
  105.  
  106.     LT_SetAttributes(Manager,GAD_CLEAR,
  107.         GA_Disabled,    Disabled || (Node && Node -> Entry -> Count == -1),
  108.     TAG_DONE);
  109.  
  110.     LT_SetAttributes(Manager,GAD_TOGGLE_ALL,
  111.         GA_Disabled,    Disabled,
  112.     TAG_DONE);
  113.  
  114.     LT_SetAttributes(Manager,GAD_SELECT_ALL,
  115.         GA_Disabled,    !NumPhoneEntries || Count == NumPhoneEntries || !PhoneList,
  116.     TAG_DONE);
  117.  
  118.     LT_SetAttributes(Manager,GAD_CLEAR_ALL,
  119.         GA_Disabled,    !Count,
  120.     TAG_DONE);
  121.  
  122.     LT_SetAttributes(Manager,GAD_PATTERN,
  123.         GA_Disabled,    !NumPhoneEntries || !PhoneList,
  124.     TAG_DONE);
  125.  
  126.     LT_SetAttributes(Manager,GAD_DIAL,
  127.         GA_Disabled,    !Node || (Online && !Config -> MiscConfig -> ProtectiveMode),
  128.     TAG_DONE);
  129.  
  130.     LT_SetAttributes(Manager,GAD_LOAD,
  131.         GA_Disabled,    ChosenEntry != NULL,
  132.     TAG_DONE);
  133.  
  134.     LT_SetAttributes(Manager,GAD_MERGE,
  135.         GA_Disabled,    !NumPhoneEntries || !PhoneList,
  136.     TAG_DONE);
  137.  
  138.     LT_SetAttributes(Manager,GAD_SAVE,
  139.         GA_Disabled,    !NumPhoneEntries || !PhoneList,
  140.     TAG_DONE);
  141.  
  142.     LT_SetAttributes(Manager,GAD_PRINT,
  143.         GA_Disabled,    !NumPhoneEntries || !PhoneList,
  144.     TAG_DONE);
  145.  
  146.     LT_SetAttributes(Manager,GAD_SORT,
  147.         GA_Disabled,    !NumPhoneEntries || !PhoneList,
  148.     TAG_DONE);
  149.  
  150.     LT_SetAttributes(Manager,GAD_COPY_CONFIG,
  151.         GA_Disabled,    !NumPhoneEntries || !PhoneList,
  152.     TAG_DONE);
  153.  
  154.     LT_SetAttributes(Manager,GAD_SORT_ORDER,
  155.         GA_Disabled,    !NumPhoneEntries || !PhoneList,
  156.     TAG_DONE);
  157.  
  158.     LT_SetAttributes(Manager,GAD_GROUPID,
  159.         GTCY_Active,    Grouper,
  160.     TAG_DONE);
  161.  
  162.     if(Editor)
  163.     {
  164.         BOOL                     IsFirst,IsLast,Disabled,RatesValid;
  165.         struct Configuration    *LocalConfig;
  166.  
  167.         if(Node)
  168.         {
  169.             IsFirst            = (Node -> Entry -> Count == -1) || (Node -> Entry -> Count == 0);
  170.             IsLast            = (Node -> Entry -> Count == -1) || (Node -> Entry -> Count == Count - 1);
  171.             Disabled        = FALSE;
  172.             LocalConfig        = Node -> Entry -> Config;
  173.             RatesValid        = (Node -> Entry -> TimeDateList . mlh_Head -> mln_Succ != NULL && !Node -> Entry -> Header -> NoRates);
  174.         }
  175.         else
  176.         {
  177.             IsFirst            = TRUE;
  178.             IsLast            = TRUE;
  179.             Disabled        = TRUE;
  180.             LocalConfig        = NULL;
  181.             RatesValid        = FALSE;
  182.         }
  183.  
  184.         LT_SetAttributes(Editor,GAD_SYSTEM_NAME,
  185.             GTST_String,    Node ? Node -> Entry -> Header -> Name : (STRPTR)"",
  186.             GA_Disabled,    Disabled,
  187.         TAG_DONE);
  188.  
  189.         LT_SetAttributes(Editor,GAD_COMMENT,
  190.             GTST_String,    Node ? Node -> Entry -> Header -> Comment : (STRPTR)"",
  191.             GA_Disabled,    Disabled,
  192.         TAG_DONE);
  193.  
  194.         LT_SetAttributes(Editor,GAD_NUMBERS,
  195.             GTST_String,    Node ? Node -> Entry -> Header -> Number : (STRPTR)"",
  196.             GA_Disabled,    Disabled,
  197.         TAG_DONE);
  198.  
  199.         LT_SetAttributes(Editor,GAD_QUICK_MENU,
  200.             GTCB_Checked,    Node ? Node -> Entry -> Header -> QuickMenu : FALSE,
  201.             GA_Disabled,    Disabled,
  202.         TAG_DONE);
  203.  
  204.         LT_SetAttributes(Editor,GAD_AUTODIAL,
  205.             GTCB_Checked,    Node ? Node -> Entry -> Header -> AutoDial : FALSE,
  206.             GA_Disabled,    Disabled,
  207.         TAG_DONE);
  208.  
  209.         LT_SetAttributes(Editor,GAD_USER_NAME,
  210.             GTST_String,    (Node && !Hide) ? Node -> Entry -> Header -> UserName : (STRPTR)"",
  211.             GA_Disabled,    Hide || Disabled,
  212.         TAG_DONE);
  213.  
  214.         LT_SetAttributes(Editor,GAD_USER_PASSWORD,
  215.             GTST_String,    (Node && !Hide) ? Node -> Entry -> Header -> Password : (STRPTR)"",
  216.             GA_Disabled,    Hide || Disabled,
  217.         TAG_DONE);
  218.  
  219.  
  220.         LT_SetAttributes(Editor,GAD_SERIAL_STATE,
  221.             GTCB_Checked,    LocalConfig ? (LocalConfig -> SerialConfig != NULL) : FALSE,
  222.             GA_Disabled,    Disabled,
  223.         TAG_DONE);
  224.  
  225.         LT_SetAttributes(Editor,GAD_SERIAL_EDIT,
  226. #ifndef ADAM_SZYMCZAK
  227.                 GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> SerialConfig),
  228. #else
  229.                 GA_Disabled,    Disabled,
  230. #endif
  231.         TAG_DONE);
  232.  
  233.         LT_SetAttributes(Editor,GAD_MODEM_STATE,
  234.             GTCB_Checked,    LocalConfig ? (LocalConfig -> ModemConfig != NULL) : FALSE,
  235.             GA_Disabled,    Disabled,
  236.         TAG_DONE);
  237.  
  238.         LT_SetAttributes(Editor,GAD_MODEM_EDIT,
  239. #ifndef ADAM_SZYMCZAK
  240.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> ModemConfig),
  241. #else
  242.             GA_Disabled,    Disabled,
  243. #endif
  244.         TAG_DONE);
  245.  
  246.         LT_SetAttributes(Editor,GAD_SCREEN_STATE,
  247.             GTCB_Checked,    LocalConfig ? (LocalConfig -> ScreenConfig != NULL) : FALSE,
  248.             GA_Disabled,    Disabled,
  249.         TAG_DONE);
  250.  
  251.         LT_SetAttributes(Editor,GAD_SCREEN_EDIT,
  252. #ifndef ADAM_SZYMCZAK
  253.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> ScreenConfig),
  254. #else
  255.             GA_Disabled,    Disabled,
  256. #endif
  257.         TAG_DONE);
  258.  
  259.         LT_SetAttributes(Editor,GAD_TERMINAL_STATE,
  260.             GTCB_Checked,    LocalConfig ? (LocalConfig -> TerminalConfig != NULL) : FALSE,
  261.             GA_Disabled,    Disabled,
  262.         TAG_DONE);
  263.  
  264.         LT_SetAttributes(Editor,GAD_TERMINAL_EDIT,
  265. #ifndef ADAM_SZYMCZAK
  266.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> TerminalConfig),
  267. #else
  268.             GA_Disabled,    Disabled,
  269. #endif
  270.         TAG_DONE);
  271.  
  272.         LT_SetAttributes(Editor,GAD_EMULATION_STATE,
  273.             GTCB_Checked,    LocalConfig ? (LocalConfig -> EmulationConfig != NULL) : FALSE,
  274.             GA_Disabled,    Disabled,
  275.         TAG_DONE);
  276.  
  277.         LT_SetAttributes(Editor,GAD_EMULATION_EDIT,
  278. #ifndef ADAM_SZYMCZAK
  279.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> EmulationConfig),
  280. #else
  281.             GA_Disabled,    Disabled,
  282. #endif
  283.         TAG_DONE);
  284.  
  285.         LT_SetAttributes(Editor,GAD_CLIPBOARD_STATE,
  286.             GTCB_Checked,    LocalConfig ? (LocalConfig -> ClipConfig != NULL) : FALSE,
  287.             GA_Disabled,    Disabled,
  288.         TAG_DONE);
  289.  
  290.         LT_SetAttributes(Editor,GAD_CLIPBOARD_EDIT,
  291. #ifndef ADAM_SZYMCZAK
  292.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> ClipConfig),
  293. #else
  294.             GA_Disabled,    Disabled,
  295. #endif
  296.         TAG_DONE);
  297.  
  298.         LT_SetAttributes(Editor,GAD_CAPTURE_STATE,
  299.             GTCB_Checked,    LocalConfig ? (LocalConfig -> CaptureConfig != NULL) : FALSE,
  300.             GA_Disabled,    Disabled,
  301.         TAG_DONE);
  302.  
  303.         LT_SetAttributes(Editor,GAD_CAPTURE_EDIT,
  304. #ifndef ADAM_SZYMCZAK
  305.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> CaptureConfig),
  306. #else
  307.             GA_Disabled,    Disabled,
  308. #endif
  309.         TAG_DONE);
  310.  
  311.         LT_SetAttributes(Editor,GAD_COMMAND_STATE,
  312.             GTCB_Checked,    LocalConfig ? (LocalConfig -> CommandConfig != NULL) : FALSE,
  313.             GA_Disabled,    Disabled,
  314.         TAG_DONE);
  315.  
  316.         LT_SetAttributes(Editor,GAD_COMMAND_EDIT,
  317. #ifndef ADAM_SZYMCZAK
  318.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> CommandConfig),
  319. #else
  320.             GA_Disabled,    Disabled,
  321. #endif
  322.         TAG_DONE);
  323.  
  324.         LT_SetAttributes(Editor,GAD_MISC_STATE,
  325.             GTCB_Checked,    LocalConfig ? (LocalConfig -> MiscConfig != NULL) : FALSE,
  326.             GA_Disabled,    Disabled,
  327.         TAG_DONE);
  328.  
  329.         LT_SetAttributes(Editor,GAD_MISC_EDIT,
  330. #ifndef ADAM_SZYMCZAK
  331.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> MiscConfig),
  332. #else
  333.             GA_Disabled,    Disabled,
  334. #endif
  335.         TAG_DONE);
  336.  
  337.         LT_SetAttributes(Editor,GAD_PATH_STATE,
  338.             GTCB_Checked,    LocalConfig ? (LocalConfig -> PathConfig != NULL) : FALSE,
  339.             GA_Disabled,    Disabled,
  340.         TAG_DONE);
  341.  
  342.         LT_SetAttributes(Editor,GAD_PATH_EDIT,
  343. #ifndef ADAM_SZYMCZAK
  344.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> PathConfig),
  345. #else
  346.             GA_Disabled,    Disabled,
  347. #endif
  348.         TAG_DONE);
  349.  
  350.         LT_SetAttributes(Editor,GAD_TRANSFER_STATE,
  351.             GTCB_Checked,    LocalConfig ? (LocalConfig -> TransferConfig != NULL) : FALSE,
  352.             GA_Disabled,    Disabled,
  353.         TAG_DONE);
  354.  
  355.         LT_SetAttributes(Editor,GAD_TRANSFER_EDIT,
  356. #ifndef ADAM_SZYMCZAK
  357.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> TransferConfig),
  358. #else
  359.             GA_Disabled,    Disabled,
  360. #endif
  361.         TAG_DONE);
  362.  
  363.         LT_SetAttributes(Editor,GAD_TRANSLATION_STATE,
  364.             GTCB_Checked,    LocalConfig ? (LocalConfig -> TranslationFileName != NULL) : FALSE,
  365.             GA_Disabled,    Disabled,
  366.         TAG_DONE);
  367.  
  368.         LT_SetAttributes(Editor,GAD_TRANSLATION_EDIT,
  369. #ifndef ADAM_SZYMCZAK
  370.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> TranslationFileName),
  371. #else
  372.             GA_Disabled,    Disabled,
  373. #endif
  374.         TAG_DONE);
  375.  
  376.         LT_SetAttributes(Editor,GAD_MACRO_STATE,
  377.             GTCB_Checked,    LocalConfig ? (LocalConfig -> MacroFileName != NULL) : FALSE,
  378.             GA_Disabled,    Disabled,
  379.         TAG_DONE);
  380.  
  381.         LT_SetAttributes(Editor,GAD_MACRO_EDIT,
  382. #ifndef ADAM_SZYMCZAK
  383.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> MacroFileName),
  384. #else
  385.             GA_Disabled,    Disabled,
  386. #endif
  387.         TAG_DONE);
  388.  
  389.         LT_SetAttributes(Editor,GAD_CURSOR_STATE,
  390.             GTCB_Checked,    LocalConfig ? (LocalConfig -> CursorFileName != NULL) : FALSE,
  391.             GA_Disabled,    Disabled,
  392.         TAG_DONE);
  393.  
  394.         LT_SetAttributes(Editor,GAD_CURSOR_EDIT,
  395. #ifndef ADAM_SZYMCZAK
  396.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> CursorFileName),
  397. #else
  398.             GA_Disabled,    Disabled,
  399. #endif
  400.         TAG_DONE);
  401.  
  402.         LT_SetAttributes(Editor,GAD_FASTMACRO_STATE,
  403.             GTCB_Checked,    LocalConfig ? (LocalConfig -> FastMacroFileName != NULL) : FALSE,
  404.             GA_Disabled,    Disabled,
  405.         TAG_DONE);
  406.  
  407.         LT_SetAttributes(Editor,GAD_FASTMACRO_EDIT,
  408. #ifndef ADAM_SZYMCZAK
  409.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> FastMacroFileName),
  410. #else
  411.             GA_Disabled,    Disabled,
  412. #endif
  413.         TAG_DONE);
  414.  
  415.         LT_SetAttributes(Editor,GAD_RATE_STATE,
  416.             GTCB_Checked,    RatesValid,
  417.             GA_Disabled,    Disabled,
  418.         TAG_DONE);
  419.  
  420.         LT_SetAttributes(Editor,GAD_RATE_EDIT,
  421. #ifndef ADAM_SZYMCZAK
  422.             GA_Disabled,    Disabled || !RatesValid,
  423. #else
  424.             GA_Disabled,    Disabled,
  425. #endif
  426.         TAG_DONE);
  427.  
  428.         LT_SetAttributes(Editor,GAD_FIRST_ENTRY,
  429.             GA_Disabled,    Disabled || IsFirst,
  430.         TAG_DONE);
  431.  
  432.         LT_SetAttributes(Editor,GAD_PREVIOUS_ENTRY,
  433.             GA_Disabled,    Disabled || IsFirst,
  434.         TAG_DONE);
  435.  
  436.         LT_SetAttributes(Editor,GAD_NEXT_ENTRY,
  437.             GA_Disabled,    Disabled || IsLast,
  438.         TAG_DONE);
  439.  
  440.         LT_SetAttributes(Editor,GAD_LAST_ENTRY,
  441.             GA_Disabled,    Disabled || IsLast,
  442.         TAG_DONE);
  443.  
  444.         if(Activate)
  445.         {
  446.             LT_ShowWindow(Editor,TRUE);
  447.  
  448.             LT_Activate(Editor,GAD_SYSTEM_NAME);
  449.         }
  450.     }
  451. }
  452.  
  453. STATIC VOID
  454. UpdateWindowTitle(struct Window *Window,STRPTR Title,LONG Count)
  455. {
  456.     if(Count)
  457.         SPrintf(Title,LocaleString(MSG_PHONEPANEL_SELECTED_OUT_OF_TXT),LocaleString(MSG_PHONEPANEL_PHONEBOOK_TXT),Count,NumPhoneEntries);
  458.     else
  459.         Title = LocaleString(MSG_PHONEPANEL_PHONEBOOK_TXT);
  460.  
  461.     SetWindowTitles(Window,Title,(STRPTR)~0);
  462. }
  463.  
  464. STATIC VOID
  465. UpdateEditorData(LayoutHandle *Editor,struct PhoneNode *Node,BOOL Hide)
  466. {
  467.     if(Editor && Node)
  468.     {
  469.         strcpy(Node -> Entry -> Header -> Name,LT_GetString(Editor,GAD_SYSTEM_NAME));
  470.         strcpy(Node -> Entry -> Header -> Comment,LT_GetString(Editor,GAD_COMMENT));
  471.         strcpy(Node -> Entry -> Header -> Number,LT_GetString(Editor,GAD_NUMBERS));
  472.  
  473.         if(!Hide)
  474.         {
  475.             strcpy(Node -> Entry -> Header -> UserName,LT_GetString(Editor,GAD_USER_NAME));
  476.             strcpy(Node -> Entry -> Header -> Password,LT_GetString(Editor,GAD_USER_PASSWORD));
  477.         }
  478.     }
  479. }
  480.  
  481. BOOL
  482. PhonePanel(ULONG MsgQualifier)
  483. {
  484.     STATIC UBYTE    NamePattern[64]        = "#?",
  485.                     NumberPattern[64]    = "#?",
  486.                     CommentPattern[64]    = "#?";
  487.     STATIC BYTE        Mode = 1;
  488.  
  489.     STATIC WORD        Sorter;
  490.     STATIC BOOLEAN        ReverseOrder;
  491.  
  492.     UBYTE                 ParsedNamePattern[130],
  493.                          ParsedNumberPattern[130],
  494.                          ParsedCommentPattern[130];
  495.  
  496.     UBYTE                 WindowTitle[80];
  497.  
  498.     struct MsgPort        *UserPort;
  499.     LayoutHandle        *Manager,
  500.                         *Editor,
  501.                         *Selector,
  502.                         *Grouping,
  503.                         *Sorting,
  504.                         *PasswordHandle;
  505.     struct PhoneNode    *TempNode;
  506.     struct List            *PhoneList;
  507.     struct List            *CurrentList;
  508.     LONG                 Count;
  509.     STRPTR                *Labels,
  510.                         *OtherLabels;
  511.     STRPTR                 Name;
  512.     LONG                 i,ListMax;
  513.     BOOL                 Hide = TRUE;
  514.     BOOL                 DialTheList = FALSE;
  515.  
  516.         // Create the group labels
  517.  
  518.     if(!(Labels = BuildLabels()))
  519.     {
  520.         DisplayBeep(Window -> WScreen);
  521.         return(FALSE);
  522.     }
  523.  
  524.         // Count the number of labels
  525.  
  526.     for(i = 0 ; Labels[i] ; i++);
  527.  
  528.         // If the group index is larger than the group label table
  529.         // permits, truncate it.
  530.  
  531.     if(PhonebookDefaultGroup >= i)
  532.         PhonebookDefaultGroup = i - 1;
  533.  
  534.         // All the control panels we will open will live on this msgport
  535.  
  536.     if(!(UserPort = CreateMsgPort()))
  537.     {
  538.         FreeVecPooled(Labels);
  539.         DisplayBeep(Window -> WScreen);
  540.         return(FALSE);
  541.     }
  542.  
  543.         // Start with a clean slate
  544.  
  545.     Manager        = NULL;
  546.     Editor        = NULL;
  547.     Selector    = NULL;
  548.     Grouping    = NULL;
  549.     Sorting        = NULL;
  550.     PasswordHandle    = NULL;
  551.  
  552.         // Does the phonebook hold any entries?
  553.  
  554.     if(Phonebook && NumPhoneEntries)
  555.     {
  556.         LONG i;
  557.  
  558.             // Create the phonebook labels
  559.  
  560.         if(!(PhoneList = CreatePhoneList()))
  561.         {
  562.             DisplayBeep(Window -> WScreen);
  563.  
  564.             FreeVecPooled(Labels);
  565.             DeleteMsgPort(UserPort);
  566.  
  567.             return(FALSE);
  568.         }
  569.  
  570.             // Get rid of the old dialing list
  571.  
  572.         FreeDialList(TRUE);
  573.  
  574.             // Now walk through the phonebook, counting the tagged entries
  575.  
  576.         for(i = 0, Count = -1 ; i < NumPhoneEntries ; i++)
  577.         {
  578.             if(Phonebook[i] -> Count > Count)
  579.                 Count = Phonebook[i] -> Count;
  580.         }
  581.  
  582.         Count++;
  583.     }
  584.     else
  585.     {
  586.         PhoneList    = NULL;
  587.         Count        = 0;
  588.     }
  589.  
  590.         // Are we to display a group?
  591.  
  592.     if(PhonebookDefaultGroup)
  593.     {
  594.         PhoneGroupNode    *Group;
  595.         struct Node        *Node;
  596.  
  597.             // Get the group list header
  598.  
  599.         Group = (PhoneGroupNode *)(((ULONG)Labels[PhonebookDefaultGroup]) - offsetof(PhoneGroupNode,LocalName));
  600.  
  601.         CurrentList = (struct List *)&Group -> GroupList;
  602.  
  603.             // Count the number of entries in the list
  604.  
  605.         for(ListMax = 0, Node = CurrentList -> lh_Head ; Node -> ln_Succ ; Node = Node -> ln_Succ)
  606.             ListMax++;
  607.     }
  608.     else
  609.     {
  610.             // We'll use the main list
  611.  
  612.         CurrentList    = PhoneList;
  613.         ListMax        = NumPhoneEntries;
  614.     }
  615.  
  616.         // Update the window title
  617.  
  618.     if(Count)
  619.         SPrintf(WindowTitle,LocaleString(MSG_PHONEPANEL_SELECTED_OUT_OF_TXT),LocaleString(MSG_PHONEPANEL_PHONEBOOK_TXT),Count,NumPhoneEntries);
  620.     else
  621.         strcpy(WindowTitle,LocaleString(MSG_PHONEPANEL_PHONEBOOK_TXT));
  622.  
  623.         // If the user holds down any shift key, the editor window will open in
  624.         // addition to the manager window
  625.  
  626.     if(MsgQualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))
  627.     {
  628.         if(Editor = CreateEditorHandle(Window,CurrentList,Count,NULL,FALSE,UserPort))
  629.             Manager = CreateManagerHandle(Editor -> Window,CurrentList,Count,&PhonebookDefaultGroup,Labels,UserPort,WindowTitle);
  630.     }
  631.     else
  632.         Manager = CreateManagerHandle(Window,CurrentList,Count,&PhonebookDefaultGroup,Labels,UserPort,WindowTitle);
  633.  
  634.         // Don't go any further if the manager window is not open
  635.  
  636.     if(Manager)
  637.     {
  638.         struct IntuiMessage        *Message;
  639.         BOOL                     Done = FALSE;
  640.         BOOL                     ClearList = FALSE;
  641.         ULONG                     MsgClass,
  642.                                  MsgQualifier,
  643.                                  CompleteQualifier;
  644.         UWORD                     MsgCode;
  645.         LONG                     KeyCode;
  646.         struct Gadget            *MsgGadget;
  647.         struct Window            *MsgWindow;
  648.  
  649.         LONG                     ClickAction;
  650.  
  651.         UBYTE                     DummyBuffer[MAX_FILENAME_LENGTH],
  652.                                 *DummyChar;
  653.  
  654.         LONG                     Selected = ~0,
  655.                                  MsgGadgetID;
  656.  
  657.         struct PhoneNode        *SelectedNode = NULL;
  658.         struct PhoneEntry        *Entry;
  659.  
  660.         struct FileRequester    *FileRequest;
  661.         LONG                     Vanilla;
  662.  
  663.         struct Window            *PhoneWindow    = Manager -> Window;
  664.         struct Window            *EditWindow        = NULL;
  665.         struct Window            *PatternWindow    = NULL;
  666.         struct Window            *GroupWindow    = NULL;
  667.         struct Window            *SortWindow        = NULL;
  668.         struct Window            *PasswordWindow    = NULL;
  669.         LayoutHandle            *Handle;
  670.  
  671.             // Save this one for later
  672.  
  673.         if(Editor)
  674.             EditWindow = Editor -> Window;
  675.  
  676.         GuideContext(CONTEXT_PHONEBOOK);
  677.  
  678.         PushWindow(PhoneWindow);
  679.  
  680.         do
  681.         {
  682.             if(Wait(PORTMASK(PhoneWindow -> UserPort) | SIG_BREAK) & SIG_BREAK)
  683.             {
  684.                 FreeDialList(TRUE);
  685.  
  686.                 break;
  687.             }
  688.  
  689.             while(Message = (struct IntuiMessage *)GT_GetIMsg(PhoneWindow -> UserPort))
  690.             {
  691.                 MsgClass        = Message -> Class;
  692.                 MsgQualifier    = Message -> Qualifier;
  693.                 MsgCode            = Message -> Code;
  694.                 MsgGadget        = (struct Gadget *)Message -> IAddress;
  695.                 MsgWindow        = Message -> IDCMPWindow;
  696.  
  697.                 GT_ReplyIMsg(Message);
  698.  
  699.                     // Jump to the handle the message originated from
  700.  
  701.                 if(MsgWindow == PhoneWindow)
  702.                     Handle = Manager;
  703.  
  704.                 if(MsgWindow == EditWindow)
  705.                     Handle = Editor;
  706.  
  707.                 if(MsgWindow == PatternWindow)
  708.                     Handle = Selector;
  709.  
  710.                 if(MsgWindow == GroupWindow)
  711.                     Handle = Grouping;
  712.  
  713.                 if(MsgWindow == SortWindow)
  714.                     Handle = Sorting;
  715.  
  716.                 if(MsgWindow == PasswordWindow)
  717.                     Handle = PasswordHandle;
  718.  
  719.                     // Save the original event qualifier
  720.  
  721.                 CompleteQualifier = MsgQualifier;
  722.  
  723.                     // Now, this is not nice, but needs to be done in order
  724.                     // to avoid having keyboard movements mess up the list of
  725.                     // tagged entries.
  726.  
  727.                 if(MsgClass == IDCMP_RAWKEY && (MsgCode >= CURSORUP && MsgCode <= CURSORDOWN))
  728.                     MsgQualifier &= ~(IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT);
  729.  
  730.                     // We'll save the key code for the editing window
  731.  
  732.                 if(MsgClass == IDCMP_RAWKEY)
  733.                     KeyCode = MsgCode;
  734.                 else
  735.                     KeyCode = 0;
  736.  
  737.                     // Let gtlayout take its share
  738.  
  739.                 LT_HandleInput(Handle,CompleteQualifier,&MsgClass,&MsgCode,&MsgGadget);
  740.  
  741.                     // Extract the gadget ID
  742.  
  743.                 if(MsgClass == IDCMP_GADGETUP || MsgClass == IDCMP_IDCMPUPDATE)
  744.                     MsgGadgetID = MsgGadget -> GadgetID;
  745.                 else
  746.                     MsgGadgetID = -1;
  747.  
  748.                     // Now convert the raw key code for special commands
  749.  
  750.                 Vanilla = LT_GetCode(CompleteQualifier,MsgClass,MsgCode,MsgGadget);
  751.  
  752.                 switch(Vanilla)
  753.                 {
  754.                         // Toggle the current entry
  755.  
  756.                     case ' ':
  757.  
  758.                         if(SelectedNode)
  759.                         {
  760.                             LT_SetAttributes(Handle,GAD_NAMELIST,
  761.                                 GTLV_Labels,    ~0,
  762.                             TAG_DONE);
  763.  
  764.                             if(SelectedNode -> Entry -> Count == -1)
  765.                             {
  766.                                 SelectedNode -> Entry -> Count = Count++;
  767.  
  768.                                 SPrintf(SelectedNode -> LocalName,"%3ld - %s",Count,SelectedNode -> Entry -> Header -> Name);
  769.  
  770.                                 if(SelectedNode -> Entry -> NodeGroup)
  771.                                     strcpy(SelectedNode -> Entry -> NodeGroup -> LocalName,SelectedNode -> LocalName);
  772.  
  773.                                 UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  774.                             }
  775.                             else
  776.                             {
  777.                                 RemoveDialEntry(SelectedNode);
  778.  
  779.                                 Count--;
  780.  
  781.                                 UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  782.                             }
  783.  
  784.                             LT_SetAttributes(Handle,GAD_NAMELIST,
  785.                                 GTLV_Labels,        CurrentList,
  786.                             TAG_DONE);
  787.  
  788.                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,FALSE);
  789.                         }
  790.  
  791.                         break;
  792.  
  793.                         // Untag this or all entries
  794.  
  795.                     case 127:
  796.  
  797.                         if(CompleteQualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))
  798.                         {
  799.                             if(Count > 0)
  800.                             {
  801.                                 MsgClass    = IDCMP_GADGETUP;
  802.                                 MsgGadgetID    = GAD_CLEAR_ALL;
  803.  
  804.                                 LT_PressButton(Handle,MsgGadgetID);
  805.                             }
  806.                         }
  807.                         else
  808.                         {
  809.                             if(Selected != -1 && SelectedNode -> Entry -> Count != -1)
  810.                             {
  811.                                 MsgClass    = IDCMP_GADGETUP;
  812.                                 MsgGadgetID    = GAD_CLEAR;
  813.  
  814.                                 LT_PressButton(Handle,MsgGadgetID);
  815.                             }
  816.                         }
  817.  
  818.                         break;
  819.                 }
  820.  
  821.                     // Moving around through the editing window
  822.  
  823.                 if(MsgWindow == EditWindow && KeyCode)
  824.                 {
  825.                     switch(KeyCode)
  826.                     {
  827.                         case CURSORLEFT:
  828.  
  829.                             MsgGadgetID = -1;
  830.  
  831.                             if(SelectedNode && SelectedNode -> Entry -> Count > 0)
  832.                             {
  833.                                 MsgClass = IDCMP_GADGETUP;
  834.  
  835.                                 if(CompleteQualifier & (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT))
  836.                                     MsgGadgetID    = GAD_FIRST_ENTRY;
  837.                                 else
  838.                                     MsgGadgetID    = GAD_PREVIOUS_ENTRY;
  839.  
  840.                                 LT_PressButton(Handle,MsgGadgetID);
  841.                             }
  842.  
  843.                             break;
  844.  
  845.                         case CURSORRIGHT:
  846.  
  847.                             MsgGadgetID = -1;
  848.  
  849.                             if(SelectedNode && SelectedNode -> Entry -> Count < Count - 1)
  850.                             {
  851.                                 MsgClass = IDCMP_GADGETUP;
  852.  
  853.                                 if(CompleteQualifier & (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT))
  854.                                     MsgGadgetID    = GAD_LAST_ENTRY;
  855.                                 else
  856.                                     MsgGadgetID    = GAD_NEXT_ENTRY;
  857.  
  858.                                 LT_PressButton(Handle,MsgGadgetID);
  859.                             }
  860.  
  861.                             break;
  862.                     }
  863.                 }
  864.  
  865.                     // Close a window
  866.  
  867.                 if(MsgClass == IDCMP_CLOSEWINDOW)
  868.                 {
  869.                     if(MsgWindow == PhoneWindow)
  870.                     {
  871.                         FreeDialList(TRUE);
  872.  
  873.                         Done = TRUE;
  874.                     }
  875.  
  876.                     if(MsgWindow == EditWindow)
  877.                     {
  878.                         LT_DeleteHandle(Editor);
  879.  
  880.                         Editor = NULL;
  881.                         EditWindow = NULL;
  882.  
  883.                         LT_ShowWindow(Manager,TRUE);
  884.                     }
  885.  
  886.                     if(MsgWindow == PasswordWindow)
  887.                     {
  888.                         LT_DeleteHandle(PasswordHandle);
  889.  
  890.                         PasswordHandle = NULL;
  891.                         PasswordWindow = NULL;
  892.  
  893.                         LT_ShowWindow(Manager,TRUE);
  894.                     }
  895.  
  896.                     if(MsgWindow == PatternWindow)
  897.                     {
  898.                         LT_DeleteHandle(Selector);
  899.                         Selector = NULL;
  900.                         PatternWindow = NULL;
  901.  
  902.                         LT_ShowWindow(Manager,TRUE);
  903.                     }
  904.  
  905.                     if(MsgWindow == GroupWindow)
  906.                     {
  907.                         LT_DeleteHandle(Grouping);
  908.                         Grouping = NULL;
  909.                         GroupWindow = NULL;
  910.  
  911.                         LT_ShowWindow(Manager,TRUE);
  912.                     }
  913.  
  914.                     if(MsgWindow == SortWindow)
  915.                     {
  916.                         LT_DeleteHandle(Sorting);
  917.                         Sorting = NULL;
  918.                         SortWindow = NULL;
  919.  
  920.                         LT_ShowWindow(Manager,TRUE);
  921.                     }
  922.                 }
  923.  
  924.                     // Hit a gadget
  925.  
  926.                 if(MsgClass == IDCMP_GADGETUP)
  927.                 {
  928.                     switch(MsgGadgetID)
  929.                     {
  930.                             // Toggle all entries
  931.  
  932.                         case GAD_TOGGLE_ALL:
  933.                         {
  934.                             LONG LocalCount = 0;
  935.  
  936.                             LT_SetAttributes(Handle,GAD_NAMELIST,
  937.                                 GTLV_Labels,    ~0,
  938.                             TAG_DONE);
  939.  
  940.                             for(TempNode = (struct PhoneNode *)CurrentList -> lh_Head ; TempNode -> VanillaNode . ln_Succ ; TempNode = (struct PhoneNode *)TempNode -> VanillaNode . ln_Succ)
  941.                             {
  942.                                 if(TempNode -> Entry -> Count == -1)
  943.                                 {
  944.                                     if(!SelectedNode)
  945.                                     {
  946.                                         SelectedNode    = TempNode;
  947.                                         Selected        = GetNodeOffset((struct Node *)SelectedNode,CurrentList);
  948.                                     }
  949.  
  950.                                     TempNode -> Entry -> Count = LocalCount++;
  951.  
  952.                                     SPrintf(TempNode -> LocalName,"%3ld - %s",LocalCount,TempNode -> Entry -> Header -> Name);
  953.                                 }
  954.                                 else
  955.                                 {
  956.                                     TempNode -> Entry -> Count = -1;
  957.  
  958.                                     SPrintf(TempNode -> LocalName,"      %s",TempNode -> Entry -> Header -> Name);
  959.                                 }
  960.  
  961.                                 if(TempNode -> Entry -> NodeGroup)
  962.                                     strcpy(TempNode -> Entry -> NodeGroup -> LocalName,TempNode -> LocalName);
  963.                             }
  964.  
  965.                             Count = LocalCount;
  966.  
  967.                             UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  968.  
  969.                             LT_SetAttributes(Manager,GAD_NAMELIST,
  970.                                 GTLV_Labels,    CurrentList,
  971.                                 GTLV_Selected,    SelectedNode ? Selected : ~0,
  972.                             TAG_DONE);
  973.  
  974.                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,FALSE);
  975.  
  976.                             break;
  977.                         }
  978.  
  979.                             // Select all entries
  980.  
  981.                         case GAD_SELECT_ALL:
  982.  
  983.                             LT_SetAttributes(Handle,GAD_NAMELIST,
  984.                                 GTLV_Labels,    ~0,
  985.                             TAG_DONE);
  986.  
  987.                             for(TempNode = (struct PhoneNode *)CurrentList -> lh_Head ; TempNode -> VanillaNode . ln_Succ ; TempNode = (struct PhoneNode *)TempNode -> VanillaNode . ln_Succ)
  988.                             {
  989.                                 if(TempNode -> Entry -> Count == -1)
  990.                                 {
  991.                                     if(!SelectedNode)
  992.                                     {
  993.                                         SelectedNode    = TempNode;
  994.                                         Selected        = GetNodeOffset((struct Node *)SelectedNode,CurrentList);
  995.                                     }
  996.  
  997.                                     TempNode -> Entry -> Count = Count++;
  998.  
  999.                                     SPrintf(TempNode -> LocalName,"%3ld - %s",Count,TempNode -> Entry -> Header -> Name);
  1000.  
  1001.                                     if(TempNode -> Entry -> NodeGroup)
  1002.                                         strcpy(TempNode -> Entry -> NodeGroup -> LocalName,TempNode -> LocalName);
  1003.                                 }
  1004.                             }
  1005.  
  1006.                             UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  1007.  
  1008.                             LT_SetAttributes(Manager,GAD_NAMELIST,
  1009.                                 GTLV_Labels,    CurrentList,
  1010.                                 GTLV_Selected,    SelectedNode ? Selected : ~0,
  1011.                             TAG_DONE);
  1012.  
  1013.                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,FALSE);
  1014.  
  1015.                             break;
  1016.  
  1017.                             // Picked a list entry
  1018.  
  1019.                         case GAD_NAMELIST:
  1020.  
  1021.                             UpdateEditorData(Editor,SelectedNode,Hide);
  1022.  
  1023.                             Selected = MsgCode;
  1024.  
  1025.                                 // Get the selected node entry from the right list
  1026.  
  1027.                             if(PhonebookDefaultGroup)
  1028.                                 SelectedNode = (struct PhoneNode *)GetListNode(Selected,CurrentList);
  1029.                             else
  1030.                                 SelectedNode = Phonebook[Selected] -> Node;
  1031.  
  1032.                                 // Now check if the entry needs to be tagged or toggled
  1033.  
  1034.                             if(SelectedNode -> Entry -> Header -> Number[0] && SelectedNode -> Entry -> Header -> Name[0])
  1035.                             {
  1036.                                 if(MsgQualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))
  1037.                                     ClickAction = CLICK_TOGGLE;
  1038.                                 else
  1039.                                     ClickAction = CLICK_SELECT;
  1040.                             }
  1041.                             else
  1042.                                 ClickAction = CLICK_SELECT;
  1043.  
  1044.                                 // Toggle the tag
  1045.  
  1046.                             if(ClickAction == CLICK_TOGGLE)
  1047.                             {
  1048.                                 LT_SetAttributes(Handle,GAD_NAMELIST,
  1049.                                     GTLV_Labels,    ~0,
  1050.                                 TAG_DONE);
  1051.  
  1052.                                 if(SelectedNode -> Entry -> Count == -1)
  1053.                                 {
  1054.                                     SelectedNode -> Entry -> Count = Count++;
  1055.  
  1056.                                     SPrintf(SelectedNode -> LocalName,"%3ld - %s",Count,SelectedNode -> Entry -> Header -> Name);
  1057.  
  1058.                                     if(SelectedNode -> Entry -> NodeGroup)
  1059.                                         strcpy(SelectedNode -> Entry -> NodeGroup -> LocalName,SelectedNode -> LocalName);
  1060.                                 }
  1061.                                 else
  1062.                                 {
  1063.                                     RemoveDialEntry(SelectedNode);
  1064.  
  1065.                                     Count--;
  1066.                                 }
  1067.  
  1068.                                 LT_SetAttributes(Handle,GAD_NAMELIST,
  1069.                                     GTLV_Labels,        CurrentList,
  1070.                                 TAG_DONE);
  1071.                             }
  1072.  
  1073.                             UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  1074.  
  1075.                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,FALSE);
  1076.  
  1077.                             break;
  1078.  
  1079.                             // Clear all selections in this group
  1080.  
  1081.                         case GAD_CLEAR_ALL:
  1082.  
  1083.                             LT_SetAttributes(Handle,GAD_NAMELIST,
  1084.                                 GTLV_Labels,    ~0,
  1085.                             TAG_DONE);
  1086.  
  1087.                             for(TempNode = (struct PhoneNode *)CurrentList -> lh_Head ; TempNode -> VanillaNode . ln_Succ ; TempNode = (struct PhoneNode *)TempNode -> VanillaNode . ln_Succ)
  1088.                             {
  1089.                                 if(TempNode -> Entry -> Count != -1)
  1090.                                 {
  1091.                                     SPrintf(TempNode -> LocalName,"      %s",TempNode -> Entry -> Header -> Name);
  1092.  
  1093.                                     TempNode -> Entry -> Count = -1;
  1094.  
  1095.                                     Count--;
  1096.  
  1097.                                     if(TempNode -> Entry -> NodeGroup)
  1098.                                         strcpy(TempNode -> Entry -> NodeGroup -> LocalName,TempNode -> LocalName);
  1099.                                 }
  1100.                             }
  1101.  
  1102.                             UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  1103.  
  1104.                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  1105.  
  1106.                             break;
  1107.  
  1108.                             // Print the current group
  1109.  
  1110.                         case GAD_PRINT:
  1111.  
  1112.                             LT_LockWindow(PhoneWindow);
  1113.                             LT_LockWindow(PasswordWindow);
  1114.                             LT_LockWindow(EditWindow);
  1115.                             LT_LockWindow(PatternWindow);
  1116.                             LT_LockWindow(GroupWindow);
  1117.                             LT_LockWindow(SortWindow);
  1118.  
  1119.                             PrintPanel(PhoneWindow,CurrentList,Count);
  1120.  
  1121.                             LT_UnlockWindow(PhoneWindow);
  1122.                             LT_UnlockWindow(PasswordWindow);
  1123.                             LT_UnlockWindow(EditWindow);
  1124.                             LT_UnlockWindow(PatternWindow);
  1125.                             LT_UnlockWindow(GroupWindow);
  1126.                             LT_UnlockWindow(SortWindow);
  1127.  
  1128.                             LT_ShowWindow(Handle,TRUE);
  1129.  
  1130.                             break;
  1131.  
  1132.                             // Copy the setting stored with the current entry
  1133.                             // into the global settings
  1134.  
  1135.                         case GAD_USE:
  1136.  
  1137.                             UpdateEditorData(Editor,SelectedNode,Hide);
  1138.  
  1139.                             if(SelectedNode)
  1140.                             {
  1141.                                 SaveConfig(Config,PrivateConfig);
  1142.  
  1143.                                 SaveConfig(SelectedNode -> Entry -> Config,Config);
  1144.  
  1145.                                 strcpy(Password,SelectedNode -> Entry -> Header -> Password);
  1146.                                 strcpy(UserName,SelectedNode -> Entry -> Header -> UserName);
  1147.  
  1148.                                 ConfigSetup();
  1149.  
  1150.                                 Done = TRUE;
  1151.  
  1152.                                 ConfigChanged = FALSE;
  1153.                             }
  1154.  
  1155.                             break;
  1156.  
  1157.                             // Add a new phonebook entry to the group
  1158.  
  1159.                         case GAD_ADD:
  1160.  
  1161.                             UpdateEditorData(Editor,SelectedNode,Hide);
  1162.  
  1163.                             LT_SetAttributes(Handle,GAD_NAMELIST,
  1164.                                 GTLV_Labels,    ~0,
  1165.                             TAG_DONE);
  1166.  
  1167.                             if(PhoneList)
  1168.                             {
  1169.                                 DeletePhoneList(PhoneList);
  1170.  
  1171.                                 PhoneList = NULL;
  1172.                             }
  1173.  
  1174.                                 // Create the new entry
  1175.  
  1176.                             if(Entry = NewPhoneEntry())
  1177.                             {
  1178.                                     // Then fiddle with the list to display
  1179.  
  1180.                                 if(PhoneList = CreatePhoneList())
  1181.                                 {
  1182.                                         // Grab the new node
  1183.  
  1184.                                     SelectedNode = Entry->Node;
  1185.  
  1186.                                         // Are we displaying a group?
  1187.  
  1188.                                     if(PhonebookDefaultGroup)
  1189.                                     {
  1190.                                         PhoneGroupNode *Group;
  1191.  
  1192.                                             // Link this entry into the group
  1193.  
  1194.                                         Group = (PhoneGroupNode *)(((ULONG)Labels[PhonebookDefaultGroup]) - offsetof(PhoneGroupNode,LocalName));
  1195.  
  1196.                                         if(AddGroupEntry(Group,SelectedNode))
  1197.                                             ListMax++;
  1198.                                         else
  1199.                                         {
  1200.                                                 // If this went wrong, move up to the
  1201.                                                 // main list
  1202.  
  1203.                                             DisplayBeep(PhoneWindow -> WScreen);
  1204.  
  1205.                                             PhonebookDefaultGroup = 0;
  1206.  
  1207.                                             LT_SetAttributes(Manager,GAD_GROUPID,
  1208.                                                 GTCY_Active,0,
  1209.                                             TAG_DONE);
  1210.  
  1211.                                             CurrentList = PhoneList;
  1212.                                             ListMax = NumPhoneEntries;
  1213.                                         }
  1214.                                     }
  1215.                                     else
  1216.                                     {
  1217.                                             // This needs to be updated
  1218.  
  1219.                                         CurrentList = PhoneList;
  1220.                                         ListMax++;
  1221.                                     }
  1222.  
  1223.                                     Selected = ListMax - 1;
  1224.  
  1225.                                     LT_SetAttributes(Handle,GAD_NAMELIST,
  1226.                                         GTLV_Labels,        CurrentList,
  1227.                                         GTLV_Selected,        Selected,
  1228.                                         GA_Disabled,        FALSE,
  1229.                                     TAG_DONE);
  1230.  
  1231.                                         // Open the editor window so the user can edit the new entry
  1232.  
  1233.                                     if(!Editor)
  1234.                                     {
  1235.                                         if(Editor = CreateEditorHandle(Manager -> Window,CurrentList,Count,SelectedNode,TRUE,PhoneWindow -> UserPort))
  1236.                                             EditWindow = Editor -> Window;
  1237.                                     }
  1238.  
  1239.                                     HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,FALSE);
  1240.  
  1241.                                     RebuildMenu = PhonebookChanged = TRUE;
  1242.                                     UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  1243.                                 }
  1244.                                 else
  1245.                                     ClearList = TRUE;
  1246.                             }
  1247.                             else
  1248.                                 ClearList = TRUE;
  1249.  
  1250.                             break;
  1251.  
  1252.                             // Edit the current entry
  1253.  
  1254.                         case GAD_EDIT:
  1255.  
  1256.                             UpdateEditorData(Editor,SelectedNode,Hide);
  1257.  
  1258.                             if(SelectedNode)
  1259.                             {
  1260.                                 if(!Editor)
  1261.                                 {
  1262.                                     if(Editor = CreateEditorHandle(Manager -> Window,CurrentList,Count,SelectedNode,TRUE,PhoneWindow -> UserPort))
  1263.                                         EditWindow = Editor -> Window;
  1264.                                 }
  1265.                                 else
  1266.                                     HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,TRUE,Hide,FALSE);
  1267.                             }
  1268.  
  1269.                             break;
  1270.  
  1271.                             // Hide user name and password?
  1272.  
  1273.                         case GAD_HIDE_USERNAME_PASSWORD:
  1274.  
  1275.                             if(SelectedNode)
  1276.                             {
  1277.                                 if(!Hide)
  1278.                                 {
  1279.                                     strcpy(SelectedNode -> Entry -> Header -> UserName,LT_GetString(Editor,GAD_USER_NAME));
  1280.                                     strcpy(SelectedNode -> Entry -> Header -> Password,LT_GetString(Editor,GAD_USER_PASSWORD));
  1281.                                 }
  1282.  
  1283.                                 HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,TRUE,MsgCode,FALSE);
  1284.                             }
  1285.  
  1286.                             Hide = MsgCode;
  1287.  
  1288.                             break;
  1289.  
  1290.                             // Make a copy of the current entry
  1291.  
  1292.                         case GAD_COPY:
  1293.  
  1294.                             UpdateEditorData(Editor,SelectedNode,Hide);
  1295.  
  1296.                             if(SelectedNode)
  1297.                             {
  1298.                                 struct PhoneEntry *New;
  1299.  
  1300.                                 LT_SetAttributes(Handle,GAD_NAMELIST,
  1301.                                     GTLV_Labels,    ~0,
  1302.                                 TAG_DONE);
  1303.  
  1304.                                     // Create a blank entry
  1305.  
  1306.                                 if(New = NewPhoneEntry())
  1307.                                 {
  1308.                                     struct List *LocalPhoneList;
  1309.  
  1310.                                         // Create a new display list, we just
  1311.                                         // discarded the other one...
  1312.  
  1313.                                     if(LocalPhoneList = CreatePhoneList())
  1314.                                     {
  1315.                                         struct PhoneNode *Source;
  1316.                                         LONG i,Len1,Len2;
  1317.                                         LONG Copies;
  1318.                                         UBYTE TempName[80];
  1319.                                         STRPTR BaseName;
  1320.                                         STRPTR Trailer;
  1321.  
  1322.                                             // Remember where the old node pointed to
  1323.  
  1324.                                         Source = SelectedNode;
  1325.  
  1326.                                             // This is the one we just added
  1327.  
  1328.                                         SelectedNode = New->Node;
  1329.  
  1330.                                             // Is a group currently being displayed?
  1331.  
  1332.                                         if(PhonebookDefaultGroup)
  1333.                                         {
  1334.                                             PhoneGroupNode *Group;
  1335.  
  1336.                                                 // Move back to the group header
  1337.  
  1338.                                             Group = (PhoneGroupNode *)(((ULONG)Labels[PhonebookDefaultGroup]) - offsetof(PhoneGroupNode,LocalName));
  1339.  
  1340.                                                 // Add the new entry to the group
  1341.  
  1342.                                             if(AddGroupEntry(Group,SelectedNode))
  1343.                                             {
  1344.                                                 struct PhoneNode *Node;
  1345.  
  1346.                                                     // Now find out which list index this
  1347.                                                     // group entry maps to
  1348.  
  1349.                                                 SelectedNode = SelectedNode -> Entry -> NodeGroup;
  1350.  
  1351.                                                 for(Selected = 0, Node = (struct PhoneNode *)Group -> GroupList . mlh_Head ; Node -> VanillaNode . ln_Succ ; Node = (struct PhoneNode *)Node -> VanillaNode . ln_Succ)
  1352.                                                 {
  1353.                                                     if(Node == SelectedNode)
  1354.                                                         break;
  1355.                                                     else
  1356.                                                         Selected++;
  1357.                                                 }
  1358.  
  1359.                                                 ListMax++;
  1360.                                             }
  1361.                                             else
  1362.                                             {
  1363.                                                 DisplayBeep(PhoneWindow -> WScreen);
  1364.  
  1365.                                                 PhonebookDefaultGroup = 0;
  1366.  
  1367.                                                 LT_SetAttributes(Manager,GAD_GROUPID,
  1368.                                                     GTCY_Active,0,
  1369.                                                 TAG_DONE);
  1370.  
  1371.                                                 CurrentList = LocalPhoneList;
  1372.                                                 ListMax = NumPhoneEntries;
  1373.                                             }
  1374.                                         }
  1375.                                         else
  1376.                                         {
  1377.                                             CurrentList = LocalPhoneList;
  1378.                                             ListMax++;
  1379.                                             Selected = ListMax - 1;
  1380.                                         }
  1381.  
  1382.                                         CopyPhoneHeader(Source -> Entry -> Header,SelectedNode -> Entry -> Header);
  1383.  
  1384.                                         FreeTimeDateList((struct List *)&SelectedNode -> Entry -> TimeDateList);
  1385.  
  1386.                                         CopyTimeDateList((struct List *)&Source -> Entry -> TimeDateList,(struct List *)&SelectedNode -> Entry -> TimeDateList,FALSE);
  1387.  
  1388.                                             /* Allocate space for the config data. */
  1389.  
  1390.                                         for(i = PREF_SERIAL ; i <= PREF_FASTMACROFILENAME ; i++)
  1391.                                         {
  1392.                                             if(GetConfigEntry(Source -> Entry -> Config,i))
  1393.                                                 CreateConfigEntry(SelectedNode -> Entry -> Config,i);
  1394.                                         }
  1395.  
  1396.                                             /* Copy the data. */
  1397.  
  1398.                                         SaveConfig(Source -> Entry -> Config,SelectedNode -> Entry -> Config);
  1399.  
  1400.                                         RebuildMenu = PhonebookChanged = TRUE;
  1401.  
  1402.                                             // Build the "Copy <filler>of" template
  1403.  
  1404.                                         SPrintf(TempName,LocaleString(MSG_COPY_OF_TXT)," <filler>");
  1405.  
  1406.                                             // Now look where the "<filler>" ended up
  1407.  
  1408.                                         for(i = 0 ; i < strlen(TempName) ; i++)
  1409.                                         {
  1410.                                             if(!Strnicmp(&TempName[i],"<filler>",strlen("<filler>")))
  1411.                                             {
  1412.                                                     // Chop off everything after the "Copy " string
  1413.  
  1414.                                                 TempName[i] = 0;
  1415.                                                 Trailer = &TempName[i + strlen("<filler>")];
  1416.                                                 break;
  1417.                                             }
  1418.                                         }
  1419.  
  1420.                                             // Does this entry have a leading "Copy " string?
  1421.  
  1422.                                         if(!Strnicmp(TempName,SelectedNode -> Entry -> Header -> Name,strlen(TempName)))
  1423.                                         {
  1424.                                             BaseName = &SelectedNode -> Entry -> Header -> Name[strlen(TempName)];
  1425.  
  1426.                                                 // Skip the numbers
  1427.  
  1428.                                             while(*BaseName >= '0' && *BaseName <= '9')
  1429.                                                 BaseName++;
  1430.  
  1431.                                                 // Skip the spaces
  1432.  
  1433.                                             while(*BaseName == ' ')
  1434.                                                 BaseName++;
  1435.  
  1436.                                                 // If there is the trailing "of", skip it
  1437.  
  1438.                                             if(!Strnicmp(BaseName,Trailer,strlen(Trailer)))
  1439.                                                 BaseName += strlen(Trailer);
  1440.  
  1441.                                                 // Skip the spaces
  1442.  
  1443.                                             while(*BaseName == ' ')
  1444.                                                 BaseName++;
  1445.                                         }
  1446.                                         else
  1447.                                             BaseName = SelectedNode -> Entry -> Header -> Name;
  1448.  
  1449.                                         Len1 = strlen(BaseName);
  1450.  
  1451.                                         Copies = 0;
  1452.  
  1453.                                         for(i = 0 ; i < NumPhoneEntries ; i++)
  1454.                                         {
  1455.                                             if(Phonebook[i] != SelectedNode -> Entry)
  1456.                                             {
  1457.                                                 Len2 = strlen(Phonebook[i] -> Header -> Name);
  1458.  
  1459.                                                 if(Len2 >= Len1)
  1460.                                                 {
  1461.                                                     if(!Stricmp(&Phonebook[i] -> Header -> Name[Len2 - Len1],BaseName))
  1462.                                                         Copies++;
  1463.                                                 }
  1464.                                             }
  1465.                                         }
  1466.  
  1467.                                         if(Copies)
  1468.                                         {
  1469.                                             UBYTE Counter[10];
  1470.  
  1471.                                             if(Copies > 1)
  1472.                                                 SPrintf(Counter," %ld ",Copies);
  1473.                                             else
  1474.                                                 strcpy(Counter," ");
  1475.  
  1476.                                             SPrintf(TempName,LocaleString(MSG_COPY_OF_TXT),Counter);
  1477.                                             strcat(TempName," ");
  1478.  
  1479.                                             if(strlen(TempName) + strlen(BaseName) < 40)
  1480.                                             {
  1481.                                                 strcat(TempName,BaseName);
  1482.  
  1483.                                                 strcpy(SelectedNode -> Entry -> Header -> Name,TempName);
  1484.                                             }
  1485.                                         }
  1486.  
  1487.                                         SPrintf(SelectedNode -> LocalName,"      %s",SelectedNode -> Entry -> Header -> Name);
  1488.  
  1489.                                         if(SelectedNode -> Entry -> NodeGroup)
  1490.                                             strcpy(SelectedNode -> Entry -> NodeGroup -> LocalName,SelectedNode -> LocalName);
  1491.  
  1492.                                         LT_SetAttributes(Handle,GAD_NAMELIST,
  1493.                                             GTLV_Labels,    CurrentList,
  1494.                                             GTLV_Selected,    Selected,
  1495.                                         TAG_DONE);
  1496.  
  1497.                                         if(!Editor)
  1498.                                         {
  1499.                                             if(Editor = CreateEditorHandle(Manager -> Window,CurrentList,Count,SelectedNode,TRUE,PhoneWindow -> UserPort))
  1500.                                                 EditWindow = Editor -> Window;
  1501.                                         }
  1502.                                         else
  1503.                                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,TRUE,Hide,TRUE);
  1504.  
  1505.                                         if(PhoneList)
  1506.                                             DeletePhoneList(PhoneList);
  1507.  
  1508.                                         PhoneList = LocalPhoneList;
  1509.  
  1510.                                         break;
  1511.                                     }
  1512.                                 }
  1513.  
  1514.                                     // So that didn't work...
  1515.  
  1516.                                 DisplayBeep(Window -> WScreen);
  1517.  
  1518.                                 LT_SetAttributes(Handle,GAD_NAMELIST,
  1519.                                     GTLV_Labels,        CurrentList,
  1520.                                     GTLV_Selected,        Selected,
  1521.                                 TAG_DONE);
  1522.                             }
  1523.  
  1524.                             break;
  1525.  
  1526.                             // Delete the current entry
  1527.  
  1528.                         case GAD_DELETE:
  1529.  
  1530.                             if(SelectedNode)
  1531.                             {
  1532.                                     // We canot delete entries that are still in use by
  1533.                                     // the status server.
  1534.  
  1535.                                 if(SelectedNode -> Entry == ChosenEntry)
  1536.                                     ShowRequest(PhoneWindow,LocaleString(MSG_PHONEPANEL_PHONE_ENTRY_IN_USE_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT));
  1537.                                 else
  1538.                                 {
  1539.                                     struct PhoneNode    *Next;
  1540.                                     struct PhoneEntry    *Entry;
  1541.  
  1542.                                         // Disconnect the list
  1543.  
  1544.                                     LT_SetAttributes(Handle,GAD_NAMELIST,
  1545.                                         GTLV_Labels,~0,
  1546.                                     TAG_DONE);
  1547.  
  1548.                                         // Pick the node that will show up as the next
  1549.                                         // selected node.
  1550.  
  1551.                                     if(SelectedNode -> VanillaNode . ln_Succ -> ln_Succ)
  1552.                                         Next = (struct PhoneNode *)SelectedNode -> VanillaNode . ln_Succ;
  1553.                                     else
  1554.                                     {
  1555.                                         if(SelectedNode -> VanillaNode . ln_Pred -> ln_Pred)
  1556.                                             Next = (struct PhoneNode *)SelectedNode -> VanillaNode . ln_Pred;
  1557.                                         else
  1558.                                             Next = NULL;
  1559.                                     }
  1560.  
  1561.                                     if(Next)
  1562.                                         Entry = Next -> Entry;
  1563.                                     else
  1564.                                         Entry = NULL;
  1565.  
  1566.                                         // This is definitely a change
  1567.  
  1568.                                     RebuildMenu = PhonebookChanged = TRUE;
  1569.  
  1570.                                         // If this particular entry is tagged,
  1571.                                         // untag it first
  1572.  
  1573.                                     if(SelectedNode -> Entry -> Count != -1)
  1574.                                     {
  1575.                                         RemoveDialEntry(SelectedNode);
  1576.  
  1577.                                         Count--;
  1578.  
  1579.                                         UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  1580.                                     }
  1581.  
  1582.                                         // Get rid of the entry
  1583.  
  1584.                                     if(PhonebookDefaultGroup)
  1585.                                         RemPhoneEntry(SelectedNode,0);
  1586.                                     else
  1587.                                         RemPhoneEntry(NULL,Selected);
  1588.  
  1589.                                         // One less in the group...
  1590.  
  1591.                                     ListMax--;
  1592.  
  1593.                                         // Discard the list
  1594.  
  1595.                                     if(PhoneList)
  1596.                                     {
  1597.                                         DeletePhoneList(PhoneList);
  1598.  
  1599.                                         PhoneList = NULL;
  1600.                                     }
  1601.  
  1602.                                         // Are there still entries left?
  1603.  
  1604.                                     if(NumPhoneEntries > 0)
  1605.                                     {
  1606.                                             // Form a new list
  1607.  
  1608.                                         if(PhoneList = CreatePhoneList())
  1609.                                         {
  1610.                                                 // Move to the next selected entry
  1611.  
  1612.                                             if(PhonebookDefaultGroup)
  1613.                                                 SelectedNode = Next;
  1614.                                             else
  1615.                                             {
  1616.                                                 CurrentList = PhoneList;
  1617.  
  1618.                                                 SelectedNode = Entry -> Node;
  1619.                                             }
  1620.  
  1621.                                                 // Adapt the index
  1622.  
  1623.                                             if(Selected == ListMax)
  1624.                                                 Selected--;
  1625.  
  1626.                                             LT_SetAttributes(Handle,GAD_NAMELIST,
  1627.                                                 GTLV_Labels,    CurrentList,
  1628.                                                 GTLV_Selected,    Selected,
  1629.                                             TAG_DONE);
  1630.  
  1631.                                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  1632.                                             UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  1633.                                         }
  1634.                                         else
  1635.                                             ClearList = TRUE;
  1636.                                     }
  1637.                                     else
  1638.                                         ClearList = TRUE;
  1639.                                 }
  1640.                             }
  1641.  
  1642.                             if(!Count)
  1643.                             {
  1644.                                 LT_DeleteHandle(Grouping);
  1645.  
  1646.                                 Grouping = NULL;
  1647.                                 GroupWindow = NULL;
  1648.                             }
  1649.  
  1650.                             break;
  1651.  
  1652.                             // Change the system name; this is what shows up in the list
  1653.  
  1654.                         case GAD_SYSTEM_NAME:
  1655.  
  1656.                             if(SelectedNode)
  1657.                             {
  1658.                                 LT_SetAttributes(Manager,GAD_NAMELIST,
  1659.                                     GTLV_Labels,~0,
  1660.                                 TAG_DONE);
  1661.  
  1662.                                 strcpy(SelectedNode -> Entry -> Header -> Name,(STRPTR)LT_GetAttributes(Editor,GAD_SYSTEM_NAME,TAG_DONE));
  1663.  
  1664.                                 UpdatePhoneList(PhoneList);
  1665.  
  1666.                                 if(!SelectedNode -> Entry -> Header -> Name[0])
  1667.                                 {
  1668.                                     LT_SetAttributes(Manager,GAD_NAMELIST,
  1669.                                         GTLV_Labels,    ~0,
  1670.                                     TAG_DONE);
  1671.  
  1672.                                     if(SelectedNode -> Entry -> Count != -1)
  1673.                                     {
  1674.                                         RemoveDialEntry(SelectedNode);
  1675.  
  1676.                                         Count--;
  1677.  
  1678.                                         UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  1679.                                     }
  1680.                                 }
  1681.  
  1682.                                 HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  1683.  
  1684.                                 RebuildMenu = PhonebookChanged = TRUE;
  1685.  
  1686.                                 if(MsgCode == '\r')
  1687.                                     LT_Activate(Editor,GAD_COMMENT);
  1688.                             }
  1689.  
  1690.                             break;
  1691.  
  1692.                             // Change the comment; this is what shows up directly below the list
  1693.  
  1694.                         case GAD_COMMENT:
  1695.  
  1696.                             if(SelectedNode)
  1697.                             {
  1698.                                 strcpy(SelectedNode -> Entry -> Header -> Comment,(STRPTR)LT_GetAttributes(Editor,GAD_COMMENT,TAG_DONE));
  1699.  
  1700.                                 PhonebookChanged = TRUE;
  1701.  
  1702.                                 if(MsgCode == '\r')
  1703.                                     LT_Activate(Handle,GAD_NUMBERS);
  1704.  
  1705.                                 LT_SetAttributes(Manager,GAD_COMMENTLINE,
  1706.                                     GTTX_Text,    SelectedNode -> Entry -> Header -> Comment,
  1707.                                 TAG_DONE);
  1708.                             }
  1709.  
  1710.                             break;
  1711.  
  1712.                             // Put this entry into the quick dial menu or don't
  1713.  
  1714.                         case GAD_QUICK_MENU:
  1715.  
  1716.                             if(SelectedNode)
  1717.                             {
  1718.                                 if(SelectedNode -> Entry -> Header -> QuickMenu != MsgCode)
  1719.                                 {
  1720.                                     SelectedNode -> Entry -> Header -> QuickMenu = MsgCode;
  1721.  
  1722.                                     RebuildMenu = PhonebookChanged = TRUE;
  1723.                                 }
  1724.                             }
  1725.  
  1726.                             break;
  1727.  
  1728.                             // Do the same for the autodial feature
  1729.  
  1730.                         case GAD_AUTODIAL:
  1731.  
  1732.                             if(SelectedNode)
  1733.                                 SelectedNode -> Entry -> Header -> AutoDial = MsgCode;
  1734.  
  1735.                             break;
  1736.  
  1737.                             // Change the phone numbers for this entry
  1738.  
  1739.                         case GAD_NUMBERS:
  1740.  
  1741.                             if(SelectedNode)
  1742.                             {
  1743.                                 strcpy(SelectedNode -> Entry -> Header -> Number,(STRPTR)LT_GetAttributes(Editor,GAD_NUMBERS,TAG_DONE));
  1744.  
  1745.                                 PhonebookChanged = TRUE;
  1746.  
  1747.                                 if(!SelectedNode -> Entry -> Header -> Number[0])
  1748.                                 {
  1749.                                     LT_SetAttributes(Manager,GAD_NAMELIST,
  1750.                                         GTLV_Labels,    ~0,
  1751.                                     TAG_DONE);
  1752.  
  1753.                                     if(SelectedNode -> Entry -> Count != -1)
  1754.                                     {
  1755.                                         RemoveDialEntry(SelectedNode);
  1756.  
  1757.                                         Count--;
  1758.                                         UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  1759.                                     }
  1760.                                 }
  1761.  
  1762.                                 HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,FALSE);
  1763.                             }
  1764.  
  1765.                             break;
  1766.  
  1767.                             // Change the user name
  1768.  
  1769.                         case GAD_USER_NAME:
  1770.  
  1771.                             if(SelectedNode)
  1772.                             {
  1773.                                 strcpy(SelectedNode -> Entry -> Header -> UserName,(STRPTR)LT_GetAttributes(Editor,GAD_USER_NAME,TAG_DONE));
  1774.  
  1775.                                 PhonebookChanged = TRUE;
  1776.                             }
  1777.  
  1778.                             break;
  1779.  
  1780.                             // Change the login password
  1781.  
  1782.                         case GAD_USER_PASSWORD:
  1783.  
  1784.                             if(SelectedNode)
  1785.                             {
  1786.                                 strcpy(SelectedNode -> Entry -> Header -> Password,(STRPTR)LT_GetAttributes(Editor,GAD_USER_PASSWORD,TAG_DONE));
  1787.  
  1788.                                 PhonebookChanged = TRUE;
  1789.                             }
  1790.  
  1791.                             break;
  1792.  
  1793.                             // Load a new phonebook
  1794.  
  1795.                         case GAD_LOAD:
  1796.  
  1797.                             LT_LockWindow(PhoneWindow);
  1798.                             LT_LockWindow(PasswordWindow);
  1799.                             LT_LockWindow(EditWindow);
  1800.                             LT_LockWindow(PatternWindow);
  1801.                             LT_LockWindow(GroupWindow);
  1802.                             LT_LockWindow(SortWindow);
  1803.  
  1804.                                 // If an entry is still in use, don't let the user replace
  1805.                                 // the phonebook
  1806.  
  1807.                             if(ChosenEntry)
  1808.                                 ShowRequest(PhoneWindow,LocaleString(MSG_PHONEPANEL_PHONE_ENTRY_IN_USE_LOAD_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT));
  1809.                             else
  1810.                             {
  1811.                                 SplitFileName(LastPhone,&DummyChar,DummyBuffer);
  1812.  
  1813.                                 if(FileRequest = GetFile(PhoneWindow,LocaleString(MSG_PHONEPANEL_LOAD_PHONEBOOK_TXT),DummyBuffer,DummyChar,DummyBuffer,"#?.prefs",FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_LOAD_TXT),TRUE))
  1814.                                 {
  1815.                                     STRPTR *OtherLabels;
  1816.  
  1817.                                     LT_SetAttributes(Handle,GAD_NAMELIST,
  1818.                                         GTLV_Labels,    ~0,
  1819.                                     TAG_DONE);
  1820.  
  1821.                                     if(PhoneList)
  1822.                                         DeletePhoneList(PhoneList);
  1823.  
  1824.                                     LT_DeleteHandle(Grouping);
  1825.  
  1826.                                     Grouping = NULL;
  1827.                                     GroupWindow = NULL;
  1828.  
  1829.                                     if(!LoadPhonebook(DummyBuffer,NULL))
  1830.                                         ShowError(PhoneWindow,ERR_LOAD_ERROR,IoErr(),DummyBuffer);
  1831.                                     else
  1832.                                     {
  1833.                                         strcpy(LastPhone,DummyBuffer);
  1834.                                         strcpy(Config->PhonebookFileName,LastPhone);
  1835.  
  1836.                                         PhonebookChanged = FALSE;
  1837.  
  1838.                                         RebuildMenu = TRUE;
  1839.                                     }
  1840.  
  1841.                                     if(!(PhoneList = CreatePhoneList()))
  1842.                                     {
  1843.                                         LT_SetAttributes(Handle,GAD_NAMELIST,
  1844.                                             GTLV_Labels,    NULL,
  1845.                                             GTLV_Selected,    ~0,
  1846.                                             GA_Disabled,    TRUE,
  1847.                                         TAG_DONE);
  1848.                                     }
  1849.  
  1850.                                     CurrentList = PhoneList;
  1851.                                     ListMax = NumPhoneEntries;
  1852.  
  1853.                                     Selected = ~0;
  1854.                                     SelectedNode = NULL;
  1855.  
  1856.                                     Count = 0;
  1857.  
  1858.                                     FreeAslRequest(FileRequest);
  1859.  
  1860.                                         // The group labels need to be rebuilt. If we run
  1861.                                         // out of memory, access to groups other than the
  1862.                                         // main group will be blocked
  1863.  
  1864.                                     if(OtherLabels = BuildLabels())
  1865.                                     {
  1866.                                         LT_SetAttributes(Manager,GAD_GROUPID,
  1867.                                             GTCY_Labels,OtherLabels,
  1868.                                         TAG_DONE);
  1869.  
  1870.                                         FreeVecPooled(Labels);
  1871.  
  1872.                                         Labels = OtherLabels;
  1873.                                     }
  1874.                                     else
  1875.                                     {
  1876.                                         Labels[1] = NULL;
  1877.  
  1878.                                         PhonebookDefaultGroup = 0;
  1879.                                     }
  1880.  
  1881.                                     if(PhonebookDefaultGroup)
  1882.                                     {
  1883.                                         PhoneGroupNode    *Group;
  1884.                                         struct Node        *Node;
  1885.  
  1886.                                             // Grab the list we wanted
  1887.  
  1888.                                         Group = (PhoneGroupNode *)(((ULONG)Labels[PhonebookDefaultGroup]) - offsetof(PhoneGroupNode,LocalName));
  1889.  
  1890.                                         LT_SetAttributes(Manager,GAD_SPLIT_GROUP,
  1891.                                             GA_Disabled,FALSE,
  1892.                                         TAG_DONE);
  1893.  
  1894.                                         CurrentList = (struct List *)&Group -> GroupList;
  1895.  
  1896.                                         for(ListMax = 0, Node = CurrentList -> lh_Head ; Node -> ln_Succ ; Node = Node -> ln_Succ)
  1897.                                             ListMax++;
  1898.                                     }
  1899.  
  1900.                                     if(GroupWindow)
  1901.                                         LT_SetAttributes(Grouping,GAD_GROUP_LIST,GTCY_Labels,Labels,TAG_DONE);
  1902.  
  1903.                                     LT_SetAttributes(Manager,GAD_GROUPID,
  1904.                                         GTCY_Labels,    Labels,
  1905.                                         GTCY_Active,    PhonebookDefaultGroup,
  1906.                                     TAG_DONE);
  1907.  
  1908.                                     LT_SetAttributes(Manager,GAD_MAIN_AUTODIAL,
  1909.                                         GTCB_Checked,    PhonebookAutoDial,
  1910.                                     TAG_DONE);
  1911.  
  1912.                                     LT_SetAttributes(Manager,GAD_MAIN_EXIT_WHEN_FINISHED,
  1913.                                         GA_Disabled,    !PhonebookAutoDial,
  1914.                                         GTCB_Checked,    PhonebookAutoExit,
  1915.                                     TAG_DONE);
  1916.  
  1917.                                     if(CurrentList)
  1918.                                     {
  1919.                                         LT_SetAttributes(Handle,GAD_NAMELIST,
  1920.                                             GTLV_Labels,    CurrentList,
  1921.                                             GTLV_Selected,    ~0,
  1922.                                             GA_Disabled,    !ListMax,
  1923.                                         TAG_DONE);
  1924.  
  1925.                                         FreeDialList(TRUE);
  1926.                                     }
  1927.  
  1928.                                     HighlightEntry(Manager,Editor,CurrentList,NULL,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  1929.  
  1930.                                     UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  1931.                                 }
  1932.                             }
  1933.  
  1934.                             LT_UnlockWindow(PhoneWindow);
  1935.                             LT_UnlockWindow(PasswordWindow);
  1936.                             LT_UnlockWindow(EditWindow);
  1937.                             LT_UnlockWindow(PatternWindow);
  1938.                             LT_UnlockWindow(GroupWindow);
  1939.                             LT_UnlockWindow(SortWindow);
  1940.  
  1941.                             break;
  1942.  
  1943.                             // Merge existing phonebook with a new phonebook loaded from disk
  1944.  
  1945.                         case GAD_MERGE:
  1946.  
  1947.                             UpdateEditorData(Editor,SelectedNode,Hide);
  1948.  
  1949.                             LT_LockWindow(PhoneWindow);
  1950.                             LT_LockWindow(PasswordWindow);
  1951.                             LT_LockWindow(EditWindow);
  1952.                             LT_LockWindow(PatternWindow);
  1953.                             LT_LockWindow(GroupWindow);
  1954.                             LT_LockWindow(SortWindow);
  1955.  
  1956.                             if(ChosenEntry)
  1957.                                 ShowRequest(PhoneWindow,LocaleString(MSG_PHONEPANEL_PHONE_ENTRY_IN_USE_LOAD_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT));
  1958.                             else
  1959.                             {
  1960.                                 PhonebookHandle BookHandle;
  1961.  
  1962.                                 memset(&BookHandle,0,sizeof(BookHandle));
  1963.  
  1964.                                 CopyMem(PhonePassword,BookHandle . PhonePassword,256);
  1965.                                 BookHandle . PhonePasswordUsed = PhonePasswordUsed;
  1966.  
  1967.                                 SplitFileName(LastPhone,&DummyChar,DummyBuffer);
  1968.  
  1969.                                 if(FileRequest = GetFile(PhoneWindow,LocaleString(MSG_PHONEPANEL_LOAD_PHONEBOOK_TXT),DummyBuffer,DummyChar,DummyBuffer,"#?.prefs",FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_LOAD_TXT),TRUE))
  1970.                                 {
  1971.                                     STRPTR *OtherLabels;
  1972.  
  1973.                                     LT_SetAttributes(Handle,GAD_NAMELIST,
  1974.                                         GTLV_Labels,    ~0,
  1975.                                     TAG_DONE);
  1976.  
  1977.                                     if(PhoneList)
  1978.                                         DeletePhoneList(PhoneList);
  1979.  
  1980.                                     if(!LoadPhonebook(DummyBuffer,&BookHandle))
  1981.                                         ShowError(PhoneWindow,ERR_LOAD_ERROR,IoErr(),DummyBuffer);
  1982.                                     else
  1983.                                     {
  1984.                                         if(MergePhonebook(&BookHandle))
  1985.                                             PhonebookChanged = RebuildMenu = TRUE;
  1986.                                         else
  1987.                                             DeletePhonebook(BookHandle . Phonebook,BookHandle . PhoneSize,TRUE);
  1988.                                     }
  1989.  
  1990.                                     if(PhoneList = CreatePhoneList())
  1991.                                     {
  1992.                                         LT_SetAttributes(Handle,GAD_NAMELIST,
  1993.                                             GTLV_Labels,    PhoneList,
  1994.                                             GTLV_Selected,    ~0,
  1995.                                             GA_Disabled,    FALSE,
  1996.                                         TAG_DONE);
  1997.  
  1998.                                         FreeDialList(TRUE);
  1999.                                     }
  2000.                                     else
  2001.                                     {
  2002.                                         LT_SetAttributes(Handle,GAD_NAMELIST,
  2003.                                             GTLV_Labels,    NULL,
  2004.                                             GTLV_Selected,    ~0,
  2005.                                             GA_Disabled,    TRUE,
  2006.                                         TAG_DONE);
  2007.                                     }
  2008.  
  2009.                                     CurrentList = PhoneList;
  2010.                                     ListMax = NumPhoneEntries;
  2011.  
  2012.                                     Selected = ~0;
  2013.                                     SelectedNode = NULL;
  2014.  
  2015.                                     Count = 0;
  2016.  
  2017.                                     HighlightEntry(Manager,Editor,CurrentList,NULL,Count,PhonebookDefaultGroup = 0,FALSE,Hide,TRUE);
  2018.  
  2019.                                     FreeAslRequest(FileRequest);
  2020.  
  2021.                                     if(OtherLabels = BuildLabels())
  2022.                                     {
  2023.                                         LT_SetAttributes(Manager,GAD_GROUPID,
  2024.                                             GTCY_Labels,OtherLabels,
  2025.                                         TAG_DONE);
  2026.  
  2027.                                         FreeVecPooled(Labels);
  2028.  
  2029.                                         Labels = OtherLabels;
  2030.                                     }
  2031.                                     else
  2032.                                     {
  2033.                                         Labels[1] = NULL;
  2034.  
  2035.                                         PhonebookDefaultGroup = 0;
  2036.                                     }
  2037.  
  2038.                                     if(GroupWindow)
  2039.                                         LT_SetAttributes(Grouping,GAD_GROUP_LIST,GTCY_Labels,Labels,TAG_DONE);
  2040.  
  2041.                                     LT_SetAttributes(Manager,GAD_GROUPID,
  2042.                                         GTCY_Labels,    Labels,
  2043.                                         GTCY_Active,    0,
  2044.                                     TAG_DONE);
  2045.  
  2046.                                     UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  2047.                                 }
  2048.                             }
  2049.  
  2050.                             LT_UnlockWindow(PhoneWindow);
  2051.                             LT_UnlockWindow(PasswordWindow);
  2052.                             LT_UnlockWindow(EditWindow);
  2053.                             LT_UnlockWindow(PatternWindow);
  2054.                             LT_UnlockWindow(GroupWindow);
  2055.                             LT_UnlockWindow(SortWindow);
  2056.  
  2057.                             break;
  2058.  
  2059.                             // Join the currently tagged entries in a new group
  2060.  
  2061.                         case GAD_MAKE_GROUP:
  2062.  
  2063.                             if(GroupWindow)
  2064.                             {
  2065.                                 LT_ShowWindow(Grouping,TRUE);
  2066.                                 LT_Activate(Grouping,GAD_GROUP_NAME);
  2067.                             }
  2068.                             else
  2069.                             {
  2070.                                 if(Grouping = CreateGroupHandle(PhoneWindow,Labels,PhonebookDefaultGroup))
  2071.                                     GroupWindow = Grouping -> Window;
  2072.                             }
  2073.  
  2074.                             break;
  2075.  
  2076.                             // Copy the selected group name into the text entry field
  2077.  
  2078.                         case GAD_GROUP_LIST:
  2079.  
  2080.                             LT_SetAttributes(Grouping,GAD_GROUP_NAME,
  2081.                                 GTST_String,    Labels[MsgCode],
  2082.                             TAG_DONE);
  2083.  
  2084.                             break;
  2085.  
  2086.                             // Do something to the selected entries.
  2087.  
  2088.                         case GAD_GROUP_OK:
  2089.  
  2090.                             LT_LockWindow(PhoneWindow);
  2091.                             LT_LockWindow(PasswordWindow);
  2092.                             LT_LockWindow(EditWindow);
  2093.                             LT_LockWindow(PatternWindow);
  2094.                             LT_LockWindow(GroupWindow);
  2095.                             LT_LockWindow(SortWindow);
  2096.  
  2097.                             LT_SetAttributes(Manager,GAD_NAMELIST,
  2098.                                 GTLV_Labels,    ~0,
  2099.                             TAG_DONE);
  2100.  
  2101.                                 // Which group should the tagged entries go into?
  2102.  
  2103.                             Name = (STRPTR)LT_GetAttributes(Grouping,GAD_GROUP_NAME,TAG_DONE);
  2104.  
  2105.                                 // If it's "All", then the entries will be removed from the
  2106.                                 // subgroups and end up in the main group
  2107.  
  2108.                             if(!Stricmp(Name,Labels[0]))
  2109.                             {
  2110.                                 struct PhoneNode *Next;
  2111.  
  2112.                                 for(TempNode = (struct PhoneNode *)CurrentList -> lh_Head ; Next = (struct PhoneNode *)TempNode -> VanillaNode . ln_Succ ; TempNode = Next)
  2113.                                 {
  2114.                                     if(TempNode -> Entry -> ThisGroup && TempNode -> Entry -> Count != -1)
  2115.                                     {
  2116.                                         Remove(TempNode -> Entry -> NodeGroup);
  2117.  
  2118.                                         FreeVecPooled(TempNode -> Entry -> NodeGroup);
  2119.  
  2120.                                         TempNode -> Entry -> ThisGroup = NULL;
  2121.                                         TempNode -> Entry -> NodeGroup = NULL;
  2122.                                     }
  2123.                                 }
  2124.                             }
  2125.                             else
  2126.                             {
  2127.                                 PhoneGroupNode    *GroupNode;
  2128.                                 PhoneGroupNode    *WhichGroup        = NULL;
  2129.                                 BOOL             RenameGroup    = TRUE,
  2130.                                                  Success        = TRUE;
  2131.  
  2132.                                     // Check if the requested group already exists. In this
  2133.                                     // case, the user wants to move entries from one group
  2134.                                     // to another.
  2135.  
  2136.                                 for(GroupNode = (PhoneGroupNode *)PhoneGroupList . mlh_Head ; GroupNode -> Node . ln_Succ ; GroupNode = (PhoneGroupNode *)GroupNode -> Node . ln_Succ)
  2137.                                 {
  2138.                                     if(!Stricmp(GroupNode -> Node . ln_Name,Name))
  2139.                                     {
  2140.                                         RenameGroup = FALSE;
  2141.                                         break;
  2142.                                     }
  2143.                                 }
  2144.  
  2145.                                     // Are we displaying a group list at all?
  2146.  
  2147.                                 if(CurrentList && CurrentList != PhoneList)
  2148.                                 {
  2149.                                     struct PhoneNode *SomeNode;
  2150.  
  2151.                                     for(SomeNode = (struct PhoneNode *)CurrentList -> lh_Head ; SomeNode -> VanillaNode . ln_Succ ; SomeNode = (struct PhoneNode *)SomeNode -> VanillaNode . ln_Succ)
  2152.                                     {
  2153.                                         if(SomeNode -> Entry -> Count != -1)
  2154.                                         {
  2155.                                             WhichGroup = SomeNode -> Entry -> ThisGroup;
  2156.                                             break;
  2157.                                         }
  2158.                                     }
  2159.  
  2160.                                         // If there is no group to play with, don't rename it
  2161.  
  2162.                                     if(!WhichGroup)
  2163.                                         RenameGroup = FALSE;
  2164.                                 }
  2165.                                 else
  2166.                                     RenameGroup = FALSE;
  2167.  
  2168.                                     // Check if the marked entries are already
  2169.                                     // members of the same group
  2170.  
  2171.                                 if(RenameGroup)
  2172.                                 {
  2173.                                     LONG i,NotGrouped = 0,InGroup = 0;
  2174.  
  2175.                                     for(i = 0 ; RenameGroup && i < NumPhoneEntries ; i++)
  2176.                                     {
  2177.                                         if(Phonebook[i] -> Count != -1)
  2178.                                         {
  2179.                                             if(Phonebook[i] -> ThisGroup)
  2180.                                             {
  2181.                                                 if(NotGrouped)
  2182.                                                     RenameGroup = FALSE;
  2183.                                                 else
  2184.                                                 {
  2185.                                                     if(Phonebook[i] -> ThisGroup == WhichGroup)
  2186.                                                         InGroup++;
  2187.                                                     else
  2188.                                                         RenameGroup = FALSE;
  2189.                                                 }
  2190.                                             }
  2191.                                             else
  2192.                                             {
  2193.                                                 if(WhichGroup)
  2194.                                                     RenameGroup = FALSE;
  2195.                                                 else
  2196.                                                     NotGrouped++;
  2197.                                             }
  2198.                                         }
  2199.                                         else
  2200.                                         {
  2201.                                             if(Phonebook[i] -> ThisGroup == WhichGroup)
  2202.                                                 InGroup++;
  2203.                                         }
  2204.                                     }
  2205.  
  2206.                                         // If we should continue, check if there are
  2207.                                         // any group members at all and if all members
  2208.                                         // of the group are selected.
  2209.  
  2210.                                     if(NotGrouped || InGroup != Count)
  2211.                                         RenameGroup = FALSE;
  2212.                                 }
  2213.  
  2214.                                 if(RenameGroup)
  2215.                                 {
  2216.                                     strcpy(WhichGroup -> LocalName,Name);
  2217.  
  2218.                                     GroupNode = WhichGroup;
  2219.                                 }
  2220.                                 else
  2221.                                 {
  2222.                                         // Either find an existing group of the given name
  2223.                                         // or make a new group.
  2224.  
  2225.                                     if(GroupNode = CreatePhoneGroup(Name,&PhoneGroupList))
  2226.                                     {
  2227.                                         struct PhoneNode    *Next;
  2228.                                         LONG                 Total = 0;
  2229.  
  2230.                                             // Add the tagged entries to the group
  2231.  
  2232.                                         for(TempNode = (struct PhoneNode *)CurrentList -> lh_Head ; Next = (struct PhoneNode *)TempNode -> VanillaNode . ln_Succ ; TempNode = Next)
  2233.                                         {
  2234.                                             if(TempNode -> Entry -> Count != -1)
  2235.                                             {
  2236.                                                 AddGroupEntry(GroupNode,TempNode);
  2237.                                                 Total++;
  2238.                                             }
  2239.                                         }
  2240.  
  2241.                                         if(!Total && SelectedNode)
  2242.                                             AddGroupEntry(GroupNode,SelectedNode);
  2243.                                     }
  2244.                                     else
  2245.                                         Success = FALSE;
  2246.                                 }
  2247.  
  2248.                                 if(Success)
  2249.                                 {
  2250.                                     STRPTR *OtherLabels;
  2251.  
  2252.                                         // Now update the labels
  2253.  
  2254.                                     if(OtherLabels = BuildLabels())
  2255.                                     {
  2256.                                         PhoneGroupNode *This;
  2257.  
  2258.                                         LT_SetAttributes(Manager,GAD_GROUPID,
  2259.                                             GTCY_Labels,OtherLabels,
  2260.                                         TAG_DONE);
  2261.  
  2262.                                         FreeVecPooled(Labels);
  2263.  
  2264.                                         Labels = OtherLabels;
  2265.  
  2266.                                         CurrentList = (struct List *)&GroupNode -> GroupList;
  2267.  
  2268.                                         for(PhonebookDefaultGroup = 1, This = (PhoneGroupNode *)PhoneGroupList . mlh_Head ; This -> Node . ln_Succ ; This = (PhoneGroupNode *)This -> Node . ln_Succ)
  2269.                                         {
  2270.                                             if(This == GroupNode)
  2271.                                                 break;
  2272.                                             else
  2273.                                                 PhonebookDefaultGroup++;
  2274.                                         }
  2275.                                     }
  2276.                                     else
  2277.                                     {
  2278.                                         Labels[1] = NULL;
  2279.  
  2280.                                         PhonebookDefaultGroup = 0;
  2281.  
  2282.                                         CurrentList = PhoneList;
  2283.                                         ListMax = NumPhoneEntries;
  2284.                                     }
  2285.  
  2286.                                     if(GroupWindow)
  2287.                                     {
  2288.                                         LT_SetAttributes(Grouping,GAD_GROUP_LIST,
  2289.                                             GTCY_Labels,    Labels,
  2290.                                             GTCY_Active,    PhonebookDefaultGroup,
  2291.                                         TAG_DONE);
  2292.                                     }
  2293.  
  2294.                                     LT_SetAttributes(Manager,GAD_GROUPID,
  2295.                                         GTCY_Labels,    Labels,
  2296.                                         GTCY_Active,    PhonebookDefaultGroup,
  2297.                                     TAG_DONE);
  2298.  
  2299.                                     RebuildMenu = PhonebookChanged = TRUE;
  2300.                                 }
  2301.                                 else
  2302.                                     DisplayBeep(PhoneWindow -> WScreen);
  2303.                             }
  2304.  
  2305.                             Selected = ~0;
  2306.                             SelectedNode = NULL;
  2307.  
  2308.                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  2309.  
  2310.                             LT_UnlockWindow(PhoneWindow);
  2311.                             LT_UnlockWindow(PasswordWindow);
  2312.                             LT_UnlockWindow(EditWindow);
  2313.                             LT_UnlockWindow(PatternWindow);
  2314.                             LT_UnlockWindow(GroupWindow);
  2315.                             LT_UnlockWindow(SortWindow);
  2316.  
  2317.                             // Close the grouping window without doing anything
  2318.  
  2319.                         case GAD_GROUP_CANCEL:
  2320.  
  2321.                             LT_DeleteHandle(Grouping);
  2322.  
  2323.                             Grouping = NULL;
  2324.                             GroupWindow = NULL;
  2325.  
  2326.                             LT_ShowWindow(Manager,TRUE);
  2327.  
  2328.                             break;
  2329.  
  2330.                             // Display a different group
  2331.  
  2332.                         case GAD_GROUPID:
  2333.  
  2334.                             Selected = ~0;
  2335.                             SelectedNode = NULL;
  2336.  
  2337.                             LT_SetAttributes(Manager,GAD_NAMELIST,
  2338.                                 GTLV_Selected,    ~0,
  2339.                             TAG_DONE);
  2340.  
  2341.                                 // Special group?
  2342.  
  2343.                             if(MsgCode)
  2344.                             {
  2345.                                 PhoneGroupNode    *Group;
  2346.                                 struct Node        *Node;
  2347.  
  2348.                                     // Grab the list we wanted
  2349.  
  2350.                                 Group = (PhoneGroupNode *)(((ULONG)Labels[MsgCode]) - offsetof(PhoneGroupNode,LocalName));
  2351.  
  2352.                                 LT_SetAttributes(Manager,GAD_SPLIT_GROUP,
  2353.                                     GA_Disabled,FALSE,
  2354.                                 TAG_DONE);
  2355.  
  2356.                                 CurrentList = (struct List *)&Group -> GroupList;
  2357.  
  2358.                                 for(ListMax = 0, Node = CurrentList -> lh_Head ; Node -> ln_Succ ; Node = Node -> ln_Succ)
  2359.                                     ListMax++;
  2360.                             }
  2361.                             else
  2362.                             {
  2363.                                 LT_SetAttributes(Manager,GAD_SPLIT_GROUP,
  2364.                                     GA_Disabled,TRUE,
  2365.                                 TAG_DONE);
  2366.  
  2367.                                 CurrentList    = PhoneList;
  2368.                                 ListMax        = NumPhoneEntries;
  2369.                             }
  2370.  
  2371.                             LT_SetAttributes(Manager,GAD_NAMELIST,
  2372.                                 GTLV_Labels,CurrentList,
  2373.                             TAG_DONE);
  2374.  
  2375.                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,FALSE);
  2376.  
  2377.                             break;
  2378.  
  2379.                             // Get rid of this group
  2380.  
  2381.                         case GAD_SPLIT_GROUP:
  2382.  
  2383.                             LT_SetAttributes(Manager,GAD_NAMELIST,
  2384.                                 GTLV_Labels,~0,
  2385.                             TAG_DONE);
  2386.  
  2387.                             LT_DeleteHandle(Grouping);
  2388.  
  2389.                             Grouping = NULL;
  2390.                             GroupWindow = NULL;
  2391.  
  2392.                             Remove((struct Node *)(((ULONG)Labels[PhonebookDefaultGroup]) - offsetof(PhoneGroupNode,LocalName)));
  2393.  
  2394.                             DeletePhoneGroupNode((PhoneGroupNode *)(((ULONG)Labels[PhonebookDefaultGroup]) - offsetof(PhoneGroupNode,LocalName)));
  2395.  
  2396.                             CurrentList = PhoneList;
  2397.                             ListMax = NumPhoneEntries;
  2398.                             Selected = ~0;
  2399.                             SelectedNode = NULL;
  2400.                             PhonebookDefaultGroup = 0;
  2401.  
  2402.                                 // Now update the labels
  2403.  
  2404.                             if(OtherLabels = BuildLabels())
  2405.                             {
  2406.                                 LT_SetAttributes(Manager,GAD_GROUPID,
  2407.                                     GTCY_Labels,OtherLabels,
  2408.                                 TAG_DONE);
  2409.  
  2410.                                 FreeVecPooled(Labels);
  2411.  
  2412.                                 Labels = OtherLabels;
  2413.                             }
  2414.  
  2415.                             if(GroupWindow)
  2416.                                 LT_SetAttributes(Grouping,GAD_GROUP_LIST,GTCY_Labels,Labels,TAG_DONE);
  2417.  
  2418.                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  2419.  
  2420.                             PhonebookChanged = TRUE;
  2421.  
  2422.                             break;
  2423.  
  2424.                             // Open the sort window
  2425.  
  2426.                         case GAD_SORT:
  2427.  
  2428.                             if(Sorting)
  2429.                                 LT_ShowWindow(Sorting,TRUE);
  2430.                             else
  2431.                             {
  2432.                                 if(Sorting = CreateSortHandle(PhoneWindow,&Sorter,&ReverseOrder))
  2433.                                     SortWindow = Sorting -> Window;
  2434.                                 else
  2435.                                     DisplayBeep(SortWindow -> WScreen);
  2436.                             }
  2437.  
  2438.                             break;
  2439.  
  2440.                             // Sort the phonelist
  2441.  
  2442.                         case GAD_SORT_AND_CLOSE:
  2443.                         case GAD_SORT_IT:
  2444.  
  2445.                             UpdateEditorData(Editor,SelectedNode,Hide);
  2446.  
  2447.                             if(ListMax > 1)
  2448.                             {
  2449.                                 RebuildMenu = PhonebookChanged = TRUE;
  2450.  
  2451.                                 LT_LockWindow(PhoneWindow);
  2452.                                 LT_LockWindow(PasswordWindow);
  2453.                                 LT_LockWindow(EditWindow);
  2454.                                 LT_LockWindow(PatternWindow);
  2455.                                 LT_LockWindow(GroupWindow);
  2456.                                 LT_LockWindow(SortWindow);
  2457.  
  2458.                                 LT_SetAttributes(Manager,GAD_NAMELIST,
  2459.                                     GTLV_Labels,    ~0,
  2460.                                 TAG_DONE);
  2461.  
  2462.                                 SortPhoneEntries(PhonebookDefaultGroup ? CurrentList : NULL,Sorter,ReverseOrder);
  2463.  
  2464.                                 if(!PhonebookDefaultGroup)
  2465.                                     UpdatePhoneList(PhoneList);
  2466.  
  2467.                                 Selected = ~0;
  2468.                                 SelectedNode = NULL;
  2469.  
  2470.                                 HighlightEntry(Manager,Editor,CurrentList,NULL,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  2471.  
  2472.                                 LT_UnlockWindow(PhoneWindow);
  2473.                                 LT_UnlockWindow(PasswordWindow);
  2474.                                 LT_UnlockWindow(EditWindow);
  2475.                                 LT_UnlockWindow(PatternWindow);
  2476.                                 LT_UnlockWindow(GroupWindow);
  2477.                                 LT_UnlockWindow(SortWindow);
  2478.                             }
  2479.  
  2480.                             if(MsgGadgetID == GAD_SORT_IT)
  2481.                                 break;
  2482.  
  2483.                             // Falls through to...
  2484.  
  2485.                         case GAD_SORT_JUST_CLOSE:
  2486.  
  2487.                             LT_DeleteHandle(Sorting);
  2488.                             Sorting = NULL;
  2489.                             SortWindow = NULL;
  2490.  
  2491.                             LT_ShowWindow(Manager,TRUE);
  2492.                             break;
  2493.  
  2494.                             // Save the phonebook to disk
  2495.  
  2496.                         case GAD_SAVE:
  2497.  
  2498.                             UpdateEditorData(Editor,SelectedNode,Hide);
  2499.  
  2500.                             if(NumPhoneEntries)
  2501.                             {
  2502.                                 SplitFileName(LastPhone,&DummyChar,DummyBuffer);
  2503.  
  2504.                                 LT_LockWindow(PhoneWindow);
  2505.                                 LT_LockWindow(PasswordWindow);
  2506.                                 LT_LockWindow(EditWindow);
  2507.                                 LT_LockWindow(PatternWindow);
  2508.                                 LT_LockWindow(GroupWindow);
  2509.                                 LT_LockWindow(SortWindow);
  2510.  
  2511.                                 if(FileRequest = GetFile(PhoneWindow,LocaleString(MSG_PHONEPANEL_SAVE_PHONEBOOK_TXT),DummyBuffer,DummyChar,DummyBuffer,"#?.prefs",TRUE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SAVE_TXT),TRUE))
  2512.                                 {
  2513.                                     if(!SavePhonebook(DummyBuffer))
  2514.                                         ShowError(PhoneWindow,ERR_SAVE_ERROR,IoErr(),DummyBuffer);
  2515.                                     else
  2516.                                     {
  2517.                                         strcpy(LastPhone,DummyBuffer);
  2518.                                         strcpy(Config->PhonebookFileName,LastPhone);
  2519.  
  2520.                                         PhonebookChanged = FALSE;
  2521.                                     }
  2522.  
  2523.                                     FreeAslRequest(FileRequest);
  2524.                                 }
  2525.  
  2526.                                 LT_UnlockWindow(PhoneWindow);
  2527.                                 LT_UnlockWindow(PasswordWindow);
  2528.                                 LT_UnlockWindow(EditWindow);
  2529.                                 LT_UnlockWindow(PatternWindow);
  2530.                                 LT_UnlockWindow(GroupWindow);
  2531.                                 LT_UnlockWindow(SortWindow);
  2532.                             }
  2533.  
  2534.                             break;
  2535.  
  2536.                             // Copy cofiguration data around
  2537.  
  2538.                         case GAD_COPY_CONFIG:
  2539.                         {
  2540.                             BOOL Changes;
  2541.  
  2542.                             LT_LockWindow(PhoneWindow);
  2543.                             LT_LockWindow(PasswordWindow);
  2544.                             LT_LockWindow(EditWindow);
  2545.                             LT_LockWindow(PatternWindow);
  2546.                             LT_LockWindow(GroupWindow);
  2547.                             LT_LockWindow(SortWindow);
  2548.  
  2549.                             if(!SelectedNode)
  2550.                                 Changes = CopyPanel(PhoneWindow,NULL,Count > 0);
  2551.                             else
  2552.                                 Changes = CopyPanel(PhoneWindow,SelectedNode -> Entry -> Config,Count > 0);
  2553.  
  2554.                             if(Changes)
  2555.                             {
  2556.                                 HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  2557.  
  2558.                                 PhonebookChanged = TRUE;
  2559.                             }
  2560.  
  2561.                             LT_UnlockWindow(PhoneWindow);
  2562.                             LT_UnlockWindow(PasswordWindow);
  2563.                             LT_UnlockWindow(EditWindow);
  2564.                             LT_UnlockWindow(PatternWindow);
  2565.                             LT_UnlockWindow(GroupWindow);
  2566.                             LT_UnlockWindow(SortWindow);
  2567.  
  2568.                             LT_ShowWindow(Handle,TRUE);
  2569.  
  2570.                             break;
  2571.                         }
  2572.  
  2573.                             // Change or clear the password
  2574.  
  2575.                         case GAD_PASSWORD:
  2576.  
  2577.                             if(PasswordWindow)
  2578.                                 LT_ShowWindow(PasswordHandle,TRUE);
  2579.                             else
  2580.                             {
  2581.                                 if(PasswordHandle = CreatePasswordHandle(PhoneWindow,PhonePasswordUsed))
  2582.                                     PasswordWindow = PasswordHandle->Window;
  2583.                             }
  2584.  
  2585.                             break;
  2586.  
  2587.                             // Changed the new password
  2588.  
  2589.                         case GAD_NEW_PASSWORD:
  2590.                         case GAD_REPEAT_PASSWORD:
  2591.  
  2592.                             UpdatePasswordWindow(PasswordHandle);
  2593.                             break;
  2594.  
  2595.                         case GAD_CLEAR_PASSWORD:
  2596.  
  2597.                             PhonePasswordUsed = FALSE;
  2598.                             PhonebookChanged = TRUE;
  2599.  
  2600.                             // FALLS THROUGH TO...
  2601.  
  2602.                         case GAD_CANCEL_PASSWORD:
  2603.  
  2604.                             LT_DeleteHandle(PasswordHandle);
  2605.                             PasswordHandle = NULL;
  2606.                             PasswordWindow = NULL;
  2607.                             break;
  2608.  
  2609.                         case GAD_USE_NEW_PASSWORD:
  2610.                         {
  2611.                             UBYTE NewPassword[30];
  2612.  
  2613.                             memset(NewPassword,0,sizeof(NewPassword));
  2614.  
  2615.                             if(GetWindowPassword(Handle,NewPassword))
  2616.                             {
  2617.                                 PhonebookChanged = TRUE;
  2618.                                 PhonePasswordUsed = TRUE;
  2619.  
  2620.                                 Encrypt(NewPassword,20,PhonePassword,NewPassword,strlen(NewPassword));
  2621.  
  2622.                                 LT_DeleteHandle(PasswordHandle);
  2623.  
  2624.                                 PasswordHandle = NULL;
  2625.                                 PasswordWindow = NULL;
  2626.                             }
  2627.  
  2628.                             break;
  2629.                         }
  2630.  
  2631.                             // Close the editor window
  2632.  
  2633.                         case GAD_CLOSE:
  2634.  
  2635.                             UpdateEditorData(Editor,SelectedNode,Hide);
  2636.  
  2637.                             LT_DeleteHandle(Editor);
  2638.  
  2639.                             Editor = NULL;
  2640.                             EditWindow = NULL;
  2641.  
  2642.                             LT_ShowWindow(Manager,TRUE);
  2643.                             break;
  2644.  
  2645.                             // Move to the first tagged entry
  2646.  
  2647.                         case GAD_FIRST_ENTRY:
  2648.  
  2649.                             UpdateEditorData(Editor,SelectedNode,Hide);
  2650.  
  2651.                             if(SelectedNode)
  2652.                             {
  2653.                                 if(SelectedNode -> Entry -> Count > 0)
  2654.                                 {
  2655.                                     LONG i;
  2656.  
  2657.                                     for(i = 0 ; i < NumPhoneEntries ; i++)
  2658.                                     {
  2659.                                         if(!Phonebook[i] -> Node -> Entry -> Count)
  2660.                                         {
  2661.                                             Selected = i;
  2662.                                             SelectedNode = Phonebook[Selected] -> Node;
  2663.  
  2664.                                             if(SelectedNode -> Entry -> NodeGroup)
  2665.                                                 SelectedNode = SelectedNode -> Entry -> NodeGroup;
  2666.  
  2667.                                             FindGroup(&CurrentList,&Selected,&PhonebookDefaultGroup,PhoneList,&PhoneGroupList,SelectedNode);
  2668.  
  2669.                                             LT_SetAttributes(Manager,GAD_NAMELIST,
  2670.                                                 GTLV_Labels,    CurrentList,
  2671.                                                 GTLV_Selected,    Selected,
  2672.                                             TAG_DONE);
  2673.  
  2674.                                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,FALSE);
  2675.  
  2676.                                             break;
  2677.                                         }
  2678.                                     }
  2679.                                 }
  2680.                             }
  2681.  
  2682.                             break;
  2683.  
  2684.                             // Move to the previous tagged entry
  2685.  
  2686.                         case GAD_PREVIOUS_ENTRY:
  2687.  
  2688.                             UpdateEditorData(Editor,SelectedNode,Hide);
  2689.  
  2690.                             if(SelectedNode)
  2691.                             {
  2692.                                 if(SelectedNode -> Entry -> Count > 0)
  2693.                                 {
  2694.                                     LONG i,Index = SelectedNode -> Entry -> Count - 1;
  2695.  
  2696.                                     for(i = 0 ; i < NumPhoneEntries ; i++)
  2697.                                     {
  2698.                                         if(Phonebook[i] -> Node -> Entry -> Count == Index)
  2699.                                         {
  2700.                                             Selected = i;
  2701.                                             SelectedNode = Phonebook[Selected] -> Node;
  2702.  
  2703.                                             if(SelectedNode -> Entry -> NodeGroup)
  2704.                                                 SelectedNode = SelectedNode -> Entry -> NodeGroup;
  2705.  
  2706.                                             FindGroup(&CurrentList,&Selected,&PhonebookDefaultGroup,PhoneList,&PhoneGroupList,SelectedNode);
  2707.  
  2708.                                             LT_SetAttributes(Manager,GAD_NAMELIST,
  2709.                                                 GTLV_Labels,    CurrentList,
  2710.                                                 GTLV_Selected,    Selected,
  2711.                                             TAG_DONE);
  2712.  
  2713.                                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,FALSE);
  2714.  
  2715.                                             break;
  2716.                                         }
  2717.                                     }
  2718.                                 }
  2719.                             }
  2720.  
  2721.                             break;
  2722.  
  2723.                             // Move to the next tagged entry
  2724.  
  2725.                         case GAD_NEXT_ENTRY:
  2726.  
  2727.                             UpdateEditorData(Editor,SelectedNode,Hide);
  2728.  
  2729.                             if(SelectedNode)
  2730.                             {
  2731.                                 if(SelectedNode -> Entry -> Count < Count - 1)
  2732.                                 {
  2733.                                     LONG i,Index = SelectedNode -> Entry -> Count + 1;
  2734.  
  2735.                                     for(i = 0 ; i < NumPhoneEntries ; i++)
  2736.                                     {
  2737.                                         if(Phonebook[i] -> Node -> Entry -> Count == Index)
  2738.                                         {
  2739.                                             Selected = i;
  2740.                                             SelectedNode = Phonebook[Selected] -> Node;
  2741.  
  2742.                                             if(SelectedNode -> Entry -> NodeGroup)
  2743.                                                 SelectedNode = SelectedNode -> Entry -> NodeGroup;
  2744.  
  2745.                                             FindGroup(&CurrentList,&Selected,&PhonebookDefaultGroup,PhoneList,&PhoneGroupList,SelectedNode);
  2746.  
  2747.                                             LT_SetAttributes(Manager,GAD_NAMELIST,
  2748.                                                 GTLV_Labels,    CurrentList,
  2749.                                                 GTLV_Selected,    Selected,
  2750.                                             TAG_DONE);
  2751.  
  2752.                                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,FALSE);
  2753.  
  2754.                                             break;
  2755.                                         }
  2756.                                     }
  2757.                                 }
  2758.                             }
  2759.  
  2760.                             break;
  2761.  
  2762.                             // Move to the next tagged entry
  2763.  
  2764.                         case GAD_LAST_ENTRY:
  2765.  
  2766.                             UpdateEditorData(Editor,SelectedNode,Hide);
  2767.  
  2768.                             if(SelectedNode)
  2769.                             {
  2770.                                 if(SelectedNode -> Entry -> Count < Count - 1)
  2771.                                 {
  2772.                                     LONG i;
  2773.  
  2774.                                     for(i = 0 ; i < NumPhoneEntries ; i++)
  2775.                                     {
  2776.                                         if(Phonebook[i] -> Node -> Entry -> Count == Count - 1)
  2777.                                         {
  2778.                                             Selected = i;
  2779.                                             SelectedNode = Phonebook[Selected] -> Node;
  2780.  
  2781.                                             if(SelectedNode -> Entry -> NodeGroup)
  2782.                                                 SelectedNode = SelectedNode -> Entry -> NodeGroup;
  2783.  
  2784.                                             FindGroup(&CurrentList,&Selected,&PhonebookDefaultGroup,PhoneList,&PhoneGroupList,SelectedNode);
  2785.  
  2786.                                             LT_SetAttributes(Manager,GAD_NAMELIST,
  2787.                                                 GTLV_Labels,    CurrentList,
  2788.                                                 GTLV_Selected,    Selected,
  2789.                                             TAG_DONE);
  2790.  
  2791.                                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,FALSE);
  2792.  
  2793.                                             break;
  2794.                                         }
  2795.                                     }
  2796.                                 }
  2797.                             }
  2798.  
  2799.                             break;
  2800.  
  2801.                             // Move entry to beginning of list
  2802.  
  2803.                         case GAD_MOVE_FIRST:
  2804.  
  2805.                             if(Selected != ~0 && Selected > 0)
  2806.                             {
  2807.                                 LT_SetAttributes(Manager,GAD_NAMELIST,
  2808.                                     GTLV_Labels,~0,
  2809.                                 TAG_DONE);
  2810.  
  2811.                                 if(PhonebookDefaultGroup)
  2812.                                 {
  2813.                                     Remove((struct Node *)SelectedNode);
  2814.                                     AddHead(CurrentList,(struct Node *)SelectedNode);
  2815.  
  2816.                                     Selected = 0;
  2817.                                 }
  2818.                                 else
  2819.                                 {
  2820.                                     struct PhoneEntry    *This;
  2821.                                     LONG                 i;
  2822.  
  2823.                                     This = Phonebook[Selected];
  2824.  
  2825.                                     for(i = Selected ; i > 0 ; i--)
  2826.                                         Phonebook[i] = Phonebook[i - 1];
  2827.  
  2828.                                     Phonebook[0] = This;
  2829.  
  2830.                                     UpdatePhoneList(PhoneList);
  2831.  
  2832.                                     Selected = 0;
  2833.                                     SelectedNode = Phonebook[Selected] -> Node;
  2834.                                 }
  2835.  
  2836.                                 HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  2837.  
  2838.                                 LT_SetAttributes(Manager,GAD_NAMELIST,
  2839.                                     GTLV_Labels,        CurrentList,
  2840.                                     GTLV_Selected,        Selected,
  2841.                                 TAG_DONE);
  2842.                             }
  2843.  
  2844.                             break;
  2845.  
  2846.                             // Move entry up in the list
  2847.  
  2848.                         case GAD_MOVE_UP:
  2849.  
  2850.                             if(Selected != ~0 && Selected > 0)
  2851.                             {
  2852.                                 LT_SetAttributes(Manager,GAD_NAMELIST,
  2853.                                     GTLV_Labels,~0,
  2854.                                 TAG_DONE);
  2855.  
  2856.                                 if(PhonebookDefaultGroup)
  2857.                                 {
  2858.                                     struct Node *Other;
  2859.  
  2860.                                     Other = SelectedNode -> VanillaNode . ln_Pred -> ln_Pred;
  2861.  
  2862.                                     Remove((struct Node *)SelectedNode);
  2863.                                     Insert(CurrentList,(struct Node *)SelectedNode,Other);
  2864.  
  2865.                                     Selected--;
  2866.                                 }
  2867.                                 else
  2868.                                 {
  2869.                                     struct PhoneEntry *This;
  2870.  
  2871.                                     This                    = Phonebook[Selected];
  2872.                                     Phonebook[Selected]        = Phonebook[Selected - 1];
  2873.                                     Phonebook[Selected - 1]    = This;
  2874.  
  2875.                                     UpdatePhoneList(PhoneList);
  2876.  
  2877.                                     Selected--;
  2878.                                     SelectedNode = Phonebook[Selected] -> Node;
  2879.                                 }
  2880.  
  2881.                                 HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  2882.  
  2883.                                 LT_SetAttributes(Manager,GAD_NAMELIST,
  2884.                                     GTLV_Labels,        CurrentList,
  2885.                                     GTLV_Selected,        Selected,
  2886.                                 TAG_DONE);
  2887.                             }
  2888.  
  2889.                             break;
  2890.  
  2891.                             // Move entry down in the list
  2892.  
  2893.                         case GAD_MOVE_DOWN:
  2894.  
  2895.                             if(Selected != ~0 && Selected < ListMax - 1)
  2896.                             {
  2897.                                 LT_SetAttributes(Manager,GAD_NAMELIST,
  2898.                                     GTLV_Labels,~0,
  2899.                                 TAG_DONE);
  2900.  
  2901.                                 if(PhonebookDefaultGroup)
  2902.                                 {
  2903.                                     struct Node *Other;
  2904.  
  2905.                                     Other = SelectedNode -> VanillaNode . ln_Succ;
  2906.  
  2907.                                     Remove((struct Node *)SelectedNode);
  2908.                                     Insert(CurrentList,(struct Node *)SelectedNode,Other);
  2909.  
  2910.                                     Selected++;
  2911.                                 }
  2912.                                 else
  2913.                                 {
  2914.                                     struct PhoneEntry *This;
  2915.  
  2916.                                     This                    = Phonebook[Selected];
  2917.                                     Phonebook[Selected]        = Phonebook[Selected + 1];
  2918.                                     Phonebook[Selected + 1]    = This;
  2919.  
  2920.                                     UpdatePhoneList(PhoneList);
  2921.  
  2922.                                     Selected++;
  2923.                                     SelectedNode = Phonebook[Selected] -> Node;
  2924.                                 }
  2925.  
  2926.                                 HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  2927.  
  2928.                                 LT_SetAttributes(Manager,GAD_NAMELIST,
  2929.                                     GTLV_Labels,        CurrentList,
  2930.                                     GTLV_Selected,        Selected,
  2931.                                 TAG_DONE);
  2932.                             }
  2933.  
  2934.                             break;
  2935.  
  2936.                             // Move entry to end of list
  2937.  
  2938.                         case GAD_MOVE_LAST:
  2939.  
  2940.                             if(Selected != ~0 && Selected < ListMax - 1)
  2941.                             {
  2942.                                 LT_SetAttributes(Manager,GAD_NAMELIST,
  2943.                                     GTLV_Labels,~0,
  2944.                                 TAG_DONE);
  2945.  
  2946.                                 if(PhonebookDefaultGroup)
  2947.                                 {
  2948.                                     Remove((struct Node *)SelectedNode);
  2949.                                     AddTail(CurrentList,(struct Node *)SelectedNode);
  2950.  
  2951.                                     Selected = ListMax - 1;
  2952.                                 }
  2953.                                 else
  2954.                                 {
  2955.                                     struct PhoneEntry    *This;
  2956.                                     LONG                 i;
  2957.  
  2958.                                     This = Phonebook[Selected];
  2959.  
  2960.                                     for(i = Selected ; i < NumPhoneEntries - 1 ; i++)
  2961.                                         Phonebook[i] = Phonebook[i + 1];
  2962.  
  2963.                                     Phonebook[NumPhoneEntries - 1] = This;
  2964.  
  2965.                                     UpdatePhoneList(PhoneList);
  2966.  
  2967.                                     Selected = ListMax - 1;
  2968.                                     SelectedNode = Phonebook[Selected] -> Node;
  2969.                                 }
  2970.  
  2971.                                 HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  2972.  
  2973.                                 LT_SetAttributes(Manager,GAD_NAMELIST,
  2974.                                     GTLV_Labels,        CurrentList,
  2975.                                     GTLV_Selected,        Selected,
  2976.                                 TAG_DONE);
  2977.                             }
  2978.  
  2979.                             break;
  2980.  
  2981.                             // Fiddle with the editor checkboxes
  2982.  
  2983.                         case GAD_SERIAL_STATE:
  2984.                         case GAD_MODEM_STATE:
  2985.                         case GAD_SCREEN_STATE:
  2986.                         case GAD_TERMINAL_STATE:
  2987.                         case GAD_EMULATION_STATE:
  2988.                         case GAD_CLIPBOARD_STATE:
  2989.                         case GAD_CAPTURE_STATE:
  2990.                         case GAD_COMMAND_STATE:
  2991.                         case GAD_MISC_STATE:
  2992.                         case GAD_PATH_STATE:
  2993.                         case GAD_TRANSFER_STATE:
  2994.                         case GAD_TRANSLATION_STATE:
  2995.                         case GAD_MACRO_STATE:
  2996.                         case GAD_CURSOR_STATE:
  2997.                         case GAD_FASTMACRO_STATE:
  2998.                         case GAD_RATE_STATE:
  2999.  
  3000.                             if(Selected != ~0)
  3001.                             {
  3002.                                 if(ChangeState(MsgGadgetID,MsgCode,SelectedNode))
  3003.                                 {
  3004.                                     HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,FALSE);
  3005.  
  3006.                                     PhonebookChanged = TRUE;
  3007.                                 }
  3008.                             }
  3009.  
  3010.                             break;
  3011.  
  3012.                             // Edit the settings of the current entry
  3013.  
  3014.                         case GAD_SERIAL_EDIT:
  3015.                         case GAD_MODEM_EDIT:
  3016.                         case GAD_SCREEN_EDIT:
  3017.                         case GAD_TERMINAL_EDIT:
  3018.                         case GAD_EMULATION_EDIT:
  3019.                         case GAD_CLIPBOARD_EDIT:
  3020.                         case GAD_CAPTURE_EDIT:
  3021.                         case GAD_COMMAND_EDIT:
  3022.                         case GAD_MISC_EDIT:
  3023.                         case GAD_PATH_EDIT:
  3024.                         case GAD_TRANSFER_EDIT:
  3025.                         case GAD_TRANSLATION_EDIT:
  3026.                         case GAD_MACRO_EDIT:
  3027.                         case GAD_CURSOR_EDIT:
  3028.                         case GAD_FASTMACRO_EDIT:
  3029.                         case GAD_RATE_EDIT:
  3030.  
  3031.                             if(Selected != ~0)
  3032.                             {
  3033.                                 BOOL Result = FALSE;
  3034.  
  3035.                                 LT_LockWindow(PhoneWindow);
  3036.                                 LT_LockWindow(PasswordWindow);
  3037.                                 LT_LockWindow(EditWindow);
  3038.                                 LT_LockWindow(PatternWindow);
  3039.                                 LT_LockWindow(GroupWindow);
  3040.                                 LT_LockWindow(SortWindow);
  3041.  
  3042.                                 if(MsgGadgetID == GAD_RATE_EDIT)
  3043.                                 {
  3044.                                     if(SelectedNode -> Entry == ChosenEntry)
  3045.                                         ShowRequest(PhoneWindow,LocaleString(MSG_PHONEPANEL_PHONE_ENTRY_IN_USE_EDIT_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT),DummyBuffer);
  3046.                                     else
  3047.                                     {
  3048.                                         BOOL HadToFill = FALSE;
  3049.  
  3050.                                         if(!SelectedNode -> Entry -> TimeDateList . mlh_Head -> mln_Succ)
  3051.                                         {
  3052.                                             struct TimeDateNode *TimeDateNode;
  3053.  
  3054.                                                 // Provide defaults
  3055.  
  3056.                                             if(TimeDateNode = CreateTimeDateNode(-1,-1,"",2))
  3057.                                             {
  3058.                                                 AddTail((struct List *)&SelectedNode -> Entry -> TimeDateList,&TimeDateNode -> VanillaNode);
  3059.  
  3060.                                                 HadToFill = TRUE;
  3061.  
  3062.                                                 SelectedNode -> Entry -> Header -> NoRates = FALSE;
  3063.                                             }
  3064.                                             else
  3065.                                                 SelectedNode -> Entry -> Header -> NoRates = TRUE;    // Sorry, guv'nor
  3066.                                         }
  3067.  
  3068.                                         if(SelectedNode -> Entry -> TimeDateList . mlh_Head -> mln_Succ)
  3069.                                             Result = RatePanel(EditWindow,PhoneList,SelectedNode -> Entry,NULL);
  3070.                                         else
  3071.                                             Result = FALSE;
  3072.  
  3073.                                         if(!Result && HadToFill)
  3074.                                         {
  3075.                                                 // Discard the time/date list
  3076.  
  3077.                                             FreeTimeDateList((struct List *)&SelectedNode -> Entry -> TimeDateList);
  3078.  
  3079.                                                 // No rates here
  3080.  
  3081.                                             SelectedNode -> Entry -> Header -> NoRates = TRUE;
  3082.                                         }
  3083.                                     }
  3084.                                 }
  3085.                                 else
  3086.                                     Result = EditConfig(SelectedNode -> Entry -> Config,MsgGadgetID,MsgQualifier,EditWindow);
  3087.  
  3088.                                 if(Result)
  3089.                                 {
  3090.                                     HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,FALSE);
  3091.  
  3092.                                     PhonebookChanged = TRUE;
  3093.                                 }
  3094.  
  3095.                                 LT_UnlockWindow(PhoneWindow);
  3096.                                 LT_UnlockWindow(PasswordWindow);
  3097.                                 LT_UnlockWindow(EditWindow);
  3098.                                 LT_UnlockWindow(PatternWindow);
  3099.                                 LT_UnlockWindow(GroupWindow);
  3100.                                 LT_UnlockWindow(SortWindow);
  3101.  
  3102.                                 LT_ShowWindow(Editor,TRUE);
  3103.                             }
  3104.  
  3105.                             break;
  3106.  
  3107.                             // Open the pattern selection window
  3108.  
  3109.                         case GAD_PATTERN:
  3110.  
  3111.                             if(PatternWindow)
  3112.                             {
  3113.                                 LT_ShowWindow(Selector,TRUE);
  3114.                                 LT_Activate(Selector,GAD_SELECT_NAME);
  3115.                             }
  3116.                             else
  3117.                             {
  3118.                                 if(Selector = CreateSelectorHandle(PhoneWindow,NamePattern,NumberPattern,CommentPattern,&Mode))
  3119.                                     PatternWindow = Selector -> Window;
  3120.                                 else
  3121.                                     DisplayBeep(PhoneWindow -> WScreen);
  3122.                             }
  3123.  
  3124.                             break;
  3125.  
  3126.                             // Apply the selection pattern to the phonebook
  3127.  
  3128.                         case GAD_SELECT_APPLY:
  3129.                         case GAD_SELECT_APPLY_AND_CLOSE:
  3130.  
  3131.                             UpdateEditorData(Editor,SelectedNode,Hide);
  3132.  
  3133.                             ParsePatternNoCase(NamePattern,        ParsedNamePattern,        130);
  3134.                             ParsePatternNoCase(NumberPattern,    ParsedNumberPattern,    130);
  3135.                             ParsePatternNoCase(CommentPattern,    ParsedCommentPattern,    130);
  3136.  
  3137.                             LT_SetAttributes(Handle,GAD_NAMELIST,
  3138.                                 GTLV_Labels,    ~0,
  3139.                             TAG_DONE);
  3140.  
  3141.                             if(Mode)
  3142.                             {
  3143.                                 for(TempNode = (struct PhoneNode *)CurrentList -> lh_Head ; TempNode -> VanillaNode . ln_Succ ; TempNode = (struct PhoneNode *)TempNode -> VanillaNode . ln_Succ)
  3144.                                 {
  3145.                                     if(TempNode -> Entry -> Count == -1)
  3146.                                     {
  3147.                                         BOOL Result;
  3148.  
  3149.                                         Result = MatchPatternNoCase(ParsedNamePattern,TempNode -> Entry -> Header -> Name) & MatchPatternNoCase(ParsedNumberPattern,TempNode -> Entry -> Header -> Number) & MatchPatternNoCase(ParsedCommentPattern,TempNode -> Entry -> Header -> Comment);
  3150.  
  3151.                                         if(Result)
  3152.                                         {
  3153.                                             TempNode -> Entry -> Count = Count++;
  3154.  
  3155.                                             SPrintf(TempNode -> LocalName,"%3ld - %s",Count,TempNode -> Entry -> Header -> Name);
  3156.  
  3157.                                             if(TempNode -> Entry -> NodeGroup)
  3158.                                                 strcpy(TempNode -> Entry -> NodeGroup -> LocalName,TempNode -> LocalName);
  3159.                                         }
  3160.                                     }
  3161.                                 }
  3162.                             }
  3163.                             else
  3164.                             {
  3165.                                 for(TempNode = (struct PhoneNode *)CurrentList -> lh_Head ; TempNode -> VanillaNode . ln_Succ ; TempNode = (struct PhoneNode *)TempNode -> VanillaNode . ln_Succ)
  3166.                                 {
  3167.                                     if(TempNode -> Entry -> Count != -1)
  3168.                                     {
  3169.                                         BOOL Result;
  3170.  
  3171.                                         Result = MatchPatternNoCase(ParsedNamePattern,TempNode -> Entry -> Header -> Name) & MatchPatternNoCase(ParsedNumberPattern,TempNode -> Entry -> Header -> Number) & MatchPatternNoCase(ParsedCommentPattern,TempNode -> Entry -> Header -> Comment);
  3172.  
  3173.                                         if(Result)
  3174.                                         {
  3175.                                             RemoveDialEntry(TempNode);
  3176.  
  3177.                                             Count--;
  3178.                                         }
  3179.                                     }
  3180.                                 }
  3181.                             }
  3182.  
  3183.                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  3184.                             UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  3185.  
  3186.                             if(Count > 0)
  3187.                             {
  3188.                                 LT_SetAttributes(Manager,GAD_MAKE_GROUP,
  3189.                                     GA_Disabled,FALSE,
  3190.                                 TAG_DONE);
  3191.                             }
  3192.  
  3193.                             if(MsgGadgetID == GAD_SELECT_APPLY)
  3194.                                 break;
  3195.  
  3196.                             // Close the pattern window
  3197.  
  3198.                         case GAD_SELECT_CLOSE:
  3199.  
  3200.                             LT_DeleteHandle(Selector);
  3201.                             Selector = NULL;
  3202.                             PatternWindow = NULL;
  3203.  
  3204.                             LT_ShowWindow(Manager,TRUE);
  3205.                             break;
  3206.  
  3207.                             // Dial the selected list
  3208.  
  3209.                         case GAD_DIAL:
  3210.  
  3211.                             UpdateEditorData(Editor,SelectedNode,Hide);
  3212.  
  3213.                             if(!Count && Selected != ~0)
  3214.                             {
  3215.                                 LT_SetAttributes(Handle,GAD_NAMELIST,
  3216.                                     GTLV_Labels,    ~0,
  3217.                                 TAG_DONE);
  3218.  
  3219.                                 SPrintf(SelectedNode -> LocalName,"      %s",SelectedNode -> Entry -> Header -> Name);
  3220.  
  3221.                                 if(SelectedNode -> Entry -> NodeGroup)
  3222.                                     strcpy(SelectedNode -> Entry -> NodeGroup -> LocalName,SelectedNode -> Entry -> Header -> Name);
  3223.  
  3224.                                 SelectedNode -> Entry -> Count = Count++;
  3225.  
  3226.                                 LT_SetAttributes(Handle,GAD_NAMELIST,
  3227.                                     GTLV_Labels,    CurrentList,
  3228.                                 TAG_DONE);
  3229.  
  3230.                                 UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  3231.                             }
  3232.  
  3233.                                 /* If the modem is still online, provide help. */
  3234.  
  3235.                             if(Count > 0 && AskDial(PhoneWindow))
  3236.                             {
  3237.                                 DialTheList    = TRUE;
  3238.                                 Done        = TRUE;
  3239.                             }
  3240.  
  3241.                             break;
  3242.  
  3243.                             // Hit the autodial button
  3244.  
  3245.                         case GAD_MAIN_AUTODIAL:
  3246.  
  3247.                             LT_SetAttributes(Manager,GAD_MAIN_EXIT_WHEN_FINISHED,
  3248.                                 GA_Disabled,    !PhonebookAutoDial,
  3249.                             TAG_DONE);
  3250.  
  3251.                             break;
  3252.                     }
  3253.                 }
  3254.  
  3255.                     // Does the displayed list need clearing?
  3256.  
  3257.                 if(ClearList)
  3258.                 {
  3259.                     ClearList = FALSE;
  3260.  
  3261.                     LT_SetAttributes(Handle,GAD_NAMELIST,
  3262.                         GTLV_Labels,    NULL,
  3263.                         GTLV_Selected,    ~0,
  3264.                     TAG_DONE);
  3265.  
  3266.                     DeletePhoneGroupList(&PhoneGroupList);
  3267.  
  3268.                     if(OtherLabels = BuildLabels())
  3269.                     {
  3270.                         LT_SetAttributes(Manager,GAD_GROUPID,
  3271.                             GTCY_Labels,OtherLabels,
  3272.                         TAG_DONE);
  3273.  
  3274.                         FreeVecPooled(Labels);
  3275.  
  3276.                         Labels = OtherLabels;
  3277.                     }
  3278.                     else
  3279.                         Labels[1] = NULL;
  3280.  
  3281.                     PhonebookDefaultGroup = 0;
  3282.  
  3283.                     if(GroupWindow)
  3284.                     {
  3285.                         LT_SetAttributes(Grouping,GAD_GROUP_LIST,
  3286.                             GTCY_Labels,    Labels,
  3287.                             GTCY_Active,    PhonebookDefaultGroup,
  3288.                         TAG_DONE);
  3289.                     }
  3290.  
  3291.                     LT_SetAttributes(Manager,GAD_GROUPID,
  3292.                         GTCY_Labels,    Labels,
  3293.                         GTCY_Active,    PhonebookDefaultGroup,
  3294.                     TAG_DONE);
  3295.  
  3296.                     Selected = ~0;
  3297.                     SelectedNode = NULL;
  3298.  
  3299.                     if(PhoneList)
  3300.                     {
  3301.                         DeletePhoneList(PhoneList);
  3302.  
  3303.                         PhoneList = NULL;
  3304.                     }
  3305.  
  3306.                     CurrentList = NULL;
  3307.  
  3308.                     Count = 0;
  3309.                     ListMax = 0;
  3310.  
  3311.                     HighlightEntry(Manager,Editor,CurrentList,NULL,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  3312.                     UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  3313.  
  3314.                     LT_DeleteHandle(Grouping);
  3315.  
  3316.                     Grouping = NULL;
  3317.                     GroupWindow = NULL;
  3318.                 }
  3319.  
  3320.                     // Double-clicked on an entry?
  3321.  
  3322.                 if(MsgClass == IDCMP_IDCMPUPDATE && MsgGadgetID == GAD_NAMELIST)
  3323.                 {
  3324.                     if(!(MsgQualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT)) && !Online && Phonebook[MsgCode] -> Header -> Number[0])
  3325.                     {
  3326.                         UpdateEditorData(Editor,SelectedNode,Hide);
  3327.  
  3328.                         Selected = MsgCode;
  3329.  
  3330.                         if(PhonebookDefaultGroup)
  3331.                             SelectedNode = (struct PhoneNode *)GetListNode(Selected,CurrentList);
  3332.                         else
  3333.                             SelectedNode = Phonebook[Selected] -> Node;
  3334.  
  3335.                         LT_SetAttributes(Handle,GAD_NAMELIST,
  3336.                             GTLV_Labels,    ~0,
  3337.                         TAG_DONE);
  3338.  
  3339.                         Count = 1;
  3340.  
  3341.                         for(TempNode = (struct PhoneNode *)CurrentList -> lh_Head ; TempNode -> VanillaNode . ln_Succ ; TempNode = (struct PhoneNode *)TempNode -> VanillaNode . ln_Succ)
  3342.                         {
  3343.                             if(TempNode != SelectedNode)
  3344.                             {
  3345.                                 SPrintf(TempNode -> LocalName,"      %s",TempNode -> Entry -> Header -> Name);
  3346.  
  3347.                                 TempNode -> Entry -> Count = -1;
  3348.                             }
  3349.                             else
  3350.                             {
  3351.                                 SPrintf(TempNode -> LocalName,"  1 - %s",TempNode -> Entry -> Header -> Name);
  3352.  
  3353.                                 TempNode -> Entry -> Count = 0;
  3354.                             }
  3355.  
  3356.                             if(TempNode -> Entry -> NodeGroup)
  3357.                                 strcpy(TempNode -> Entry -> NodeGroup -> LocalName,TempNode -> LocalName);
  3358.                         }
  3359.  
  3360.                         DialTheList    = TRUE;
  3361.                         Done        = TRUE;
  3362.  
  3363.                         LT_PressButton(Handle,GAD_DIAL);
  3364.                         UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  3365.                     }
  3366.                 }
  3367.             }
  3368.         }
  3369.         while(!Done);
  3370.  
  3371.         PopWindow();
  3372.     }
  3373.  
  3374.     LT_DeleteHandle(PasswordHandle);
  3375.     LT_DeleteHandle(Grouping);
  3376.     LT_DeleteHandle(Selector);
  3377.     LT_DeleteHandle(Manager);
  3378.     LT_DeleteHandle(Editor);
  3379.     LT_DeleteHandle(Sorting);
  3380.  
  3381.     if(PhonebookChanged)
  3382.         RebuildMenu = TRUE;
  3383.  
  3384.     FreeDialList(TRUE);
  3385.  
  3386.     if(PhoneList)
  3387.     {
  3388.         if(Count > 0)
  3389.         {
  3390.             for(TempNode = (struct PhoneNode *)CurrentList -> lh_Head ; TempNode -> VanillaNode . ln_Succ ; TempNode = (struct PhoneNode *)TempNode -> VanillaNode . ln_Succ)
  3391.             {
  3392.                 if(TempNode -> Entry -> Count != -1 && TempNode -> Entry -> Header -> Number[0])
  3393.                     SortToList(TempNode,NULL);
  3394.             }
  3395.  
  3396.             if(!DialList)
  3397.                 DialTheList = FALSE;
  3398.         }
  3399.  
  3400.         DeletePhoneList(PhoneList);
  3401.     }
  3402.  
  3403.     if(RebuildMenu)
  3404.         DisconnectDialMenu();
  3405.  
  3406.     FreeVecPooled(Labels);
  3407.     DeleteMsgPort(UserPort);
  3408.  
  3409.     return(DialTheList);
  3410. }
  3411.